#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <stddef.h>
#include <time.h>
#include <pthread.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/time.h>
#include <errno.h>
#include <sys/mman.h>
#include <dlfcn.h>

Include dependency graph for sqlite3.c:

Data Structures
struct	sqlite3_file

struct	sqlite3_io_methods

struct	sqlite3_vfs

struct	sqlite3_mem_methods

struct	sqlite3_module

struct	sqlite3_index_info

struct	sqlite3_index_info::sqlite3_index_constraint

struct	sqlite3_index_info::sqlite3_index_orderby

struct	sqlite3_index_info::sqlite3_index_constraint_usage

struct	sqlite3_vtab

struct	sqlite3_vtab_cursor

struct	sqlite3_mutex_methods

struct	sqlite3_pcache_page

struct	sqlite3_pcache_methods2

struct	sqlite3_pcache_methods

struct	sqlite3_rtree_geometry

struct	sqlite3_rtree_query_info

struct	Hash

struct	Hash::_ht

struct	HashElem

struct	BusyHandler

struct	Op

struct	SubProgram

struct	VdbeOpList

struct	PgHdr

struct	Db

struct	Schema

struct	Lookaside

struct	LookasideSlot

struct	FuncDefHash

struct	sqlite3

struct	sqlite3::sqlite3InitInfo

struct	FuncDef

struct	FuncDestructor

struct	Savepoint

struct	Module

struct	Column

struct	CollSeq

struct	VTable

struct	Table

struct	FKey

struct	FKey::sColMap

struct	KeyInfo

struct	UnpackedRecord

struct	Index

struct	IndexSample

struct	Token

struct	AggInfo

struct	AggInfo::AggInfo_col

struct	AggInfo::AggInfo_func

struct	Expr

struct	ExprList

struct	ExprList::ExprList_item

struct	ExprSpan

struct	IdList

struct	IdList::IdList_item

struct	SrcList

struct	SrcList::SrcList_item

struct	NameContext

struct	Select

struct	SelectDest

struct	AutoincInfo

struct	TriggerPrg

struct	Parse

struct	Parse::yColCache

struct	AuthContext

struct	Trigger

struct	TriggerStep

struct	DbFixer

struct	StrAccum

struct	InitData

struct	Sqlite3Config

struct	Walker

struct	With

struct	With::Cte

struct	PrintfArguments

struct	VdbeCursor

struct	VdbeFrame

struct	sqlite3_value

union	sqlite3_value::MemValue

struct	AuxData

struct	sqlite3_context

struct	Explain

struct	ScanStatus

struct	Vdbe

struct	sqlite3StatType

struct	DateTime

struct	BenignMallocHooks

struct	sqlite3_mutex

struct	ScratchFreeslot

struct	Mem0Global

struct	et_info

struct	sqlite3PrngType

struct	SQLiteThread

struct	UnixUnusedFd

struct	unixFile

struct	unix_syscall

struct	vxworksFileId

struct	unixFileId

struct	unixInodeInfo

struct	unixShmNode

struct	unixShm

struct	Bitvec

struct	PCache

struct	PGroup

struct	PCache1

struct	PgHdr1

struct	PgFreeslot

struct	PCacheGlobal

struct	RowSetEntry

struct	RowSetChunk

struct	RowSet

struct	PagerSavepoint

struct	Pager

struct	WalIndexHdr

struct	WalCkptInfo

struct	Wal

struct	WalIterator

struct	WalIterator::WalSegment

struct	WalWriter

struct	MemPage

struct	BtLock

struct	Btree

struct	BtShared

struct	CellInfo

struct	BtCursor

struct	IntegrityCk

struct	sqlite3_backup

struct	ValueNewStat4Ctx

struct	Incrblob

struct	SorterFile

struct	SorterList

struct	MergeEngine

struct	SortSubtask

struct	VdbeSorter

struct	PmaReader

struct	IncrMerger

struct	PmaWriter

struct	SorterRecord

struct	FileChunk

struct	FilePoint

struct	MemJournal

struct	SrcCount

struct	Stat4Sample

struct	Stat4Accum

struct	analysisInfo

struct	TableLock

struct	compareInfo

struct	SumCtx

struct	CountCtx

struct	sqlite3_api_routines

struct	sqlite3AutoExtList

struct	sPragmaNames

struct	DistinctCtx

struct	SortCtx

struct	TabResult

struct	VtabCtx

struct	WhereLevel

struct	WhereLoop

struct	WhereOrCost

struct	WhereOrSet

struct	WherePath

struct	WhereTerm

struct	WhereScan

struct	WhereClause

struct	WhereOrInfo

struct	WhereAndInfo

struct	WhereMaskSet

struct	WhereLoopBuilder

struct	WhereInfo

struct	LimitVal

struct	LikeOp

struct	TrigEvent

struct	AttachKey

union	YYMINORTYPE

struct	yyStackEntry

struct	yyParser

Macros
#define	SQLITE_CORE 1

#define	SQLITE_AMALGAMATION 1

#define	SQLITE_PRIVATE static

#define	_SQLITEINT_H_

#define	_MSVC_H_

#define	OS_VXWORKS 0

#define	_LARGE_FILE 1

#define	_FILE_OFFSET_BITS 64

#define	_LARGEFILE_SOURCE 1

#define	_SQLITE3_H_

#define	SQLITE_EXTERN extern

#define	SQLITE_API

#define	SQLITE_CDECL

#define	SQLITE_STDCALL

#define	SQLITE_DEPRECATED

#define	SQLITE_EXPERIMENTAL

#define	SQLITE_VERSION "3.8.10"

#define	SQLITE_VERSION_NUMBER 3008010

#define	SQLITE_SOURCE_ID "2015-04-23 13:37:05 b5e43602833249aa4b73337bf85b7f308450dab6"

#define	SQLITE_OK 0 /* Successful result */

#define	SQLITE_ERROR 1 /* SQL error or missing database */

#define	SQLITE_INTERNAL 2 /* Internal logic error in SQLite */

#define	SQLITE_PERM 3 /* Access permission denied */

#define	SQLITE_ABORT 4 /* Callback routine requested an abort */

#define	SQLITE_BUSY 5 /* The database file is locked */

#define	SQLITE_LOCKED 6 /* A table in the database is locked */

#define	SQLITE_NOMEM 7 /* A malloc() failed */

#define	SQLITE_READONLY 8 /* Attempt to write a readonly database */

#define	SQLITE_INTERRUPT 9 /* Operation terminated by sqlite3_interrupt()*/

#define	SQLITE_IOERR 10 /* Some kind of disk I/O error occurred */

#define	SQLITE_CORRUPT 11 /* The database disk image is malformed */

#define	SQLITE_NOTFOUND 12 /* Unknown opcode in sqlite3_file_control() */

#define	SQLITE_FULL 13 /* Insertion failed because database is full */

#define	SQLITE_CANTOPEN 14 /* Unable to open the database file */

#define	SQLITE_PROTOCOL 15 /* Database lock protocol error */

#define	SQLITE_EMPTY 16 /* Database is empty */

#define	SQLITE_SCHEMA 17 /* The database schema changed */

#define	SQLITE_TOOBIG 18 /* String or BLOB exceeds size limit */

#define	SQLITE_CONSTRAINT 19 /* Abort due to constraint violation */

#define	SQLITE_MISMATCH 20 /* Data type mismatch */

#define	SQLITE_MISUSE 21 /* Library used incorrectly */

#define	SQLITE_NOLFS 22 /* Uses OS features not supported on host */

#define	SQLITE_AUTH 23 /* Authorization denied */

#define	SQLITE_FORMAT 24 /* Auxiliary database format error */

#define	SQLITE_RANGE 25 /* 2nd parameter to sqlite3_bind out of range */

#define	SQLITE_NOTADB 26 /* File opened that is not a database file */

#define	SQLITE_NOTICE 27 /* Notifications from sqlite3_log() */

#define	SQLITE_WARNING 28 /* Warnings from sqlite3_log() */

#define	SQLITE_ROW 100 /* sqlite3_step() has another row ready */

#define	SQLITE_DONE 101 /* sqlite3_step() has finished executing */

#define	SQLITE_IOERR_READ (SQLITE_IOERR \| (1<<8))

#define	SQLITE_IOERR_SHORT_READ (SQLITE_IOERR \| (2<<8))

#define	SQLITE_IOERR_WRITE (SQLITE_IOERR \| (3<<8))

#define	SQLITE_IOERR_FSYNC (SQLITE_IOERR \| (4<<8))

#define	SQLITE_IOERR_DIR_FSYNC (SQLITE_IOERR \| (5<<8))

#define	SQLITE_IOERR_TRUNCATE (SQLITE_IOERR \| (6<<8))

#define	SQLITE_IOERR_FSTAT (SQLITE_IOERR \| (7<<8))

#define	SQLITE_IOERR_UNLOCK (SQLITE_IOERR \| (8<<8))

#define	SQLITE_IOERR_RDLOCK (SQLITE_IOERR \| (9<<8))

#define	SQLITE_IOERR_DELETE (SQLITE_IOERR \| (10<<8))

#define	SQLITE_IOERR_BLOCKED (SQLITE_IOERR \| (11<<8))

#define	SQLITE_IOERR_NOMEM (SQLITE_IOERR \| (12<<8))

#define	SQLITE_IOERR_ACCESS (SQLITE_IOERR \| (13<<8))

#define	SQLITE_IOERR_CHECKRESERVEDLOCK (SQLITE_IOERR \| (14<<8))

#define	SQLITE_IOERR_LOCK (SQLITE_IOERR \| (15<<8))

#define	SQLITE_IOERR_CLOSE (SQLITE_IOERR \| (16<<8))

#define	SQLITE_IOERR_DIR_CLOSE (SQLITE_IOERR \| (17<<8))

#define	SQLITE_IOERR_SHMOPEN (SQLITE_IOERR \| (18<<8))

#define	SQLITE_IOERR_SHMSIZE (SQLITE_IOERR \| (19<<8))

#define	SQLITE_IOERR_SHMLOCK (SQLITE_IOERR \| (20<<8))

#define	SQLITE_IOERR_SHMMAP (SQLITE_IOERR \| (21<<8))

#define	SQLITE_IOERR_SEEK (SQLITE_IOERR \| (22<<8))

#define	SQLITE_IOERR_DELETE_NOENT (SQLITE_IOERR \| (23<<8))

#define	SQLITE_IOERR_MMAP (SQLITE_IOERR \| (24<<8))

#define	SQLITE_IOERR_GETTEMPPATH (SQLITE_IOERR \| (25<<8))

#define	SQLITE_IOERR_CONVPATH (SQLITE_IOERR \| (26<<8))

#define	SQLITE_LOCKED_SHAREDCACHE (SQLITE_LOCKED \| (1<<8))

#define	SQLITE_BUSY_RECOVERY (SQLITE_BUSY \| (1<<8))

#define	SQLITE_BUSY_SNAPSHOT (SQLITE_BUSY \| (2<<8))

#define	SQLITE_CANTOPEN_NOTEMPDIR (SQLITE_CANTOPEN \| (1<<8))

#define	SQLITE_CANTOPEN_ISDIR (SQLITE_CANTOPEN \| (2<<8))

#define	SQLITE_CANTOPEN_FULLPATH (SQLITE_CANTOPEN \| (3<<8))

#define	SQLITE_CANTOPEN_CONVPATH (SQLITE_CANTOPEN \| (4<<8))

#define	SQLITE_CORRUPT_VTAB (SQLITE_CORRUPT \| (1<<8))

#define	SQLITE_READONLY_RECOVERY (SQLITE_READONLY \| (1<<8))

#define	SQLITE_READONLY_CANTLOCK (SQLITE_READONLY \| (2<<8))

#define	SQLITE_READONLY_ROLLBACK (SQLITE_READONLY \| (3<<8))

#define	SQLITE_READONLY_DBMOVED (SQLITE_READONLY \| (4<<8))

#define	SQLITE_ABORT_ROLLBACK (SQLITE_ABORT \| (2<<8))

#define	SQLITE_CONSTRAINT_CHECK (SQLITE_CONSTRAINT \| (1<<8))

#define	SQLITE_CONSTRAINT_COMMITHOOK (SQLITE_CONSTRAINT \| (2<<8))

#define	SQLITE_CONSTRAINT_FOREIGNKEY (SQLITE_CONSTRAINT \| (3<<8))

#define	SQLITE_CONSTRAINT_FUNCTION (SQLITE_CONSTRAINT \| (4<<8))

#define	SQLITE_CONSTRAINT_NOTNULL (SQLITE_CONSTRAINT \| (5<<8))

#define	SQLITE_CONSTRAINT_PRIMARYKEY (SQLITE_CONSTRAINT \| (6<<8))

#define	SQLITE_CONSTRAINT_TRIGGER (SQLITE_CONSTRAINT \| (7<<8))

#define	SQLITE_CONSTRAINT_UNIQUE (SQLITE_CONSTRAINT \| (8<<8))

#define	SQLITE_CONSTRAINT_VTAB (SQLITE_CONSTRAINT \| (9<<8))

#define	SQLITE_CONSTRAINT_ROWID (SQLITE_CONSTRAINT \|(10<<8))

#define	SQLITE_NOTICE_RECOVER_WAL (SQLITE_NOTICE \| (1<<8))

#define	SQLITE_NOTICE_RECOVER_ROLLBACK (SQLITE_NOTICE \| (2<<8))

#define	SQLITE_WARNING_AUTOINDEX (SQLITE_WARNING \| (1<<8))

#define	SQLITE_AUTH_USER (SQLITE_AUTH \| (1<<8))

#define	SQLITE_OPEN_READONLY 0x00000001 /* Ok for sqlite3_open_v2() */

#define	SQLITE_OPEN_READWRITE 0x00000002 /* Ok for sqlite3_open_v2() */

#define	SQLITE_OPEN_CREATE 0x00000004 /* Ok for sqlite3_open_v2() */

#define	SQLITE_OPEN_DELETEONCLOSE 0x00000008 /* VFS only */

#define	SQLITE_OPEN_EXCLUSIVE 0x00000010 /* VFS only */

#define	SQLITE_OPEN_AUTOPROXY 0x00000020 /* VFS only */

#define	SQLITE_OPEN_URI 0x00000040 /* Ok for sqlite3_open_v2() */

#define	SQLITE_OPEN_MEMORY 0x00000080 /* Ok for sqlite3_open_v2() */

#define	SQLITE_OPEN_MAIN_DB 0x00000100 /* VFS only */

#define	SQLITE_OPEN_TEMP_DB 0x00000200 /* VFS only */

#define	SQLITE_OPEN_TRANSIENT_DB 0x00000400 /* VFS only */

#define	SQLITE_OPEN_MAIN_JOURNAL 0x00000800 /* VFS only */

#define	SQLITE_OPEN_TEMP_JOURNAL 0x00001000 /* VFS only */

#define	SQLITE_OPEN_SUBJOURNAL 0x00002000 /* VFS only */

#define	SQLITE_OPEN_MASTER_JOURNAL 0x00004000 /* VFS only */

#define	SQLITE_OPEN_NOMUTEX 0x00008000 /* Ok for sqlite3_open_v2() */

#define	SQLITE_OPEN_FULLMUTEX 0x00010000 /* Ok for sqlite3_open_v2() */

#define	SQLITE_OPEN_SHAREDCACHE 0x00020000 /* Ok for sqlite3_open_v2() */

#define	SQLITE_OPEN_PRIVATECACHE 0x00040000 /* Ok for sqlite3_open_v2() */

#define	SQLITE_OPEN_WAL 0x00080000 /* VFS only */

#define	SQLITE_IOCAP_ATOMIC 0x00000001

#define	SQLITE_IOCAP_ATOMIC512 0x00000002

#define	SQLITE_IOCAP_ATOMIC1K 0x00000004

#define	SQLITE_IOCAP_ATOMIC2K 0x00000008

#define	SQLITE_IOCAP_ATOMIC4K 0x00000010

#define	SQLITE_IOCAP_ATOMIC8K 0x00000020

#define	SQLITE_IOCAP_ATOMIC16K 0x00000040

#define	SQLITE_IOCAP_ATOMIC32K 0x00000080

#define	SQLITE_IOCAP_ATOMIC64K 0x00000100

#define	SQLITE_IOCAP_SAFE_APPEND 0x00000200

#define	SQLITE_IOCAP_SEQUENTIAL 0x00000400

#define	SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN 0x00000800

#define	SQLITE_IOCAP_POWERSAFE_OVERWRITE 0x00001000

#define	SQLITE_IOCAP_IMMUTABLE 0x00002000

#define	SQLITE_LOCK_NONE 0

#define	SQLITE_LOCK_SHARED 1

#define	SQLITE_LOCK_RESERVED 2

#define	SQLITE_LOCK_PENDING 3

#define	SQLITE_LOCK_EXCLUSIVE 4

#define	SQLITE_SYNC_NORMAL 0x00002

#define	SQLITE_SYNC_FULL 0x00003

#define	SQLITE_SYNC_DATAONLY 0x00010

#define	SQLITE_FCNTL_LOCKSTATE 1

#define	SQLITE_FCNTL_GET_LOCKPROXYFILE 2

#define	SQLITE_FCNTL_SET_LOCKPROXYFILE 3

#define	SQLITE_FCNTL_LAST_ERRNO 4

#define	SQLITE_FCNTL_SIZE_HINT 5

#define	SQLITE_FCNTL_CHUNK_SIZE 6

#define	SQLITE_FCNTL_FILE_POINTER 7

#define	SQLITE_FCNTL_SYNC_OMITTED 8

#define	SQLITE_FCNTL_WIN32_AV_RETRY 9

#define	SQLITE_FCNTL_PERSIST_WAL 10

#define	SQLITE_FCNTL_OVERWRITE 11

#define	SQLITE_FCNTL_VFSNAME 12

#define	SQLITE_FCNTL_POWERSAFE_OVERWRITE 13

#define	SQLITE_FCNTL_PRAGMA 14

#define	SQLITE_FCNTL_BUSYHANDLER 15

#define	SQLITE_FCNTL_TEMPFILENAME 16

#define	SQLITE_FCNTL_MMAP_SIZE 18

#define	SQLITE_FCNTL_TRACE 19

#define	SQLITE_FCNTL_HAS_MOVED 20

#define	SQLITE_FCNTL_SYNC 21

#define	SQLITE_FCNTL_COMMIT_PHASETWO 22

#define	SQLITE_FCNTL_WIN32_SET_HANDLE 23

#define	SQLITE_FCNTL_WAL_BLOCK 24

#define	SQLITE_GET_LOCKPROXYFILE SQLITE_FCNTL_GET_LOCKPROXYFILE

#define	SQLITE_SET_LOCKPROXYFILE SQLITE_FCNTL_SET_LOCKPROXYFILE

#define	SQLITE_LAST_ERRNO SQLITE_FCNTL_LAST_ERRNO

#define	SQLITE_ACCESS_EXISTS 0

#define	SQLITE_ACCESS_READWRITE 1 /* Used by PRAGMA temp_store_directory */

#define	SQLITE_ACCESS_READ 2 /* Unused */

#define	SQLITE_SHM_UNLOCK 1

#define	SQLITE_SHM_LOCK 2

#define	SQLITE_SHM_SHARED 4

#define	SQLITE_SHM_EXCLUSIVE 8

#define	SQLITE_SHM_NLOCK 8

#define	SQLITE_CONFIG_SINGLETHREAD 1 /* nil */

#define	SQLITE_CONFIG_MULTITHREAD 2 /* nil */

#define	SQLITE_CONFIG_SERIALIZED 3 /* nil */

#define	SQLITE_CONFIG_MALLOC 4 /* sqlite3_mem_methods* */

#define	SQLITE_CONFIG_GETMALLOC 5 /* sqlite3_mem_methods* */

#define	SQLITE_CONFIG_SCRATCH 6 /* void, int sz, int N /

#define	SQLITE_CONFIG_PAGECACHE 7 /* void, int sz, int N /

#define	SQLITE_CONFIG_HEAP 8 /* void, int nByte, int min /

#define	SQLITE_CONFIG_MEMSTATUS 9 /* boolean */

#define	SQLITE_CONFIG_MUTEX 10 /* sqlite3_mutex_methods* */

#define	SQLITE_CONFIG_GETMUTEX 11 /* sqlite3_mutex_methods* */

#define	SQLITE_CONFIG_LOOKASIDE 13 /* int int */

#define	SQLITE_CONFIG_PCACHE 14 /* no-op */

#define	SQLITE_CONFIG_GETPCACHE 15 /* no-op */

#define	SQLITE_CONFIG_LOG 16 /* xFunc, void* */

#define	SQLITE_CONFIG_URI 17 /* int */

#define	SQLITE_CONFIG_PCACHE2 18 /* sqlite3_pcache_methods2* */

#define	SQLITE_CONFIG_GETPCACHE2 19 /* sqlite3_pcache_methods2* */

#define	SQLITE_CONFIG_COVERING_INDEX_SCAN 20 /* int */

#define	SQLITE_CONFIG_SQLLOG 21 /* xSqllog, void* */

#define	SQLITE_CONFIG_MMAP_SIZE 22 /* sqlite3_int64, sqlite3_int64 */

#define	SQLITE_CONFIG_WIN32_HEAPSIZE 23 /* int nByte */

#define	SQLITE_CONFIG_PCACHE_HDRSZ 24 /* int psz /

#define	SQLITE_CONFIG_PMASZ 25 /* unsigned int szPma */

#define	SQLITE_DBCONFIG_LOOKASIDE 1001 /* void* int int */

#define	SQLITE_DBCONFIG_ENABLE_FKEY 1002 /* int int* */

#define	SQLITE_DBCONFIG_ENABLE_TRIGGER 1003 /* int int* */

#define	SQLITE_DENY 1 /* Abort the SQL statement with an error */

#define	SQLITE_IGNORE 2 /* Don't allow access, but don't generate an error */

#define	SQLITE_CREATE_INDEX 1 /* Index Name Table Name */

#define	SQLITE_CREATE_TABLE 2 /* Table Name NULL */

#define	SQLITE_CREATE_TEMP_INDEX 3 /* Index Name Table Name */

#define	SQLITE_CREATE_TEMP_TABLE 4 /* Table Name NULL */

#define	SQLITE_CREATE_TEMP_TRIGGER 5 /* Trigger Name Table Name */

#define	SQLITE_CREATE_TEMP_VIEW 6 /* View Name NULL */

#define	SQLITE_CREATE_TRIGGER 7 /* Trigger Name Table Name */

#define	SQLITE_CREATE_VIEW 8 /* View Name NULL */

#define	SQLITE_DELETE 9 /* Table Name NULL */

#define	SQLITE_DROP_INDEX 10 /* Index Name Table Name */

#define	SQLITE_DROP_TABLE 11 /* Table Name NULL */

#define	SQLITE_DROP_TEMP_INDEX 12 /* Index Name Table Name */

#define	SQLITE_DROP_TEMP_TABLE 13 /* Table Name NULL */

#define	SQLITE_DROP_TEMP_TRIGGER 14 /* Trigger Name Table Name */

#define	SQLITE_DROP_TEMP_VIEW 15 /* View Name NULL */

#define	SQLITE_DROP_TRIGGER 16 /* Trigger Name Table Name */

#define	SQLITE_DROP_VIEW 17 /* View Name NULL */

#define	SQLITE_INSERT 18 /* Table Name NULL */

#define	SQLITE_PRAGMA 19 /* Pragma Name 1st arg or NULL */

#define	SQLITE_READ 20 /* Table Name Column Name */

#define	SQLITE_SELECT 21 /* NULL NULL */

#define	SQLITE_TRANSACTION 22 /* Operation NULL */

#define	SQLITE_UPDATE 23 /* Table Name Column Name */

#define	SQLITE_ATTACH 24 /* Filename NULL */

#define	SQLITE_DETACH 25 /* Database Name NULL */

#define	SQLITE_ALTER_TABLE 26 /* Database Name Table Name */

#define	SQLITE_REINDEX 27 /* Index Name NULL */

#define	SQLITE_ANALYZE 28 /* Table Name NULL */

#define	SQLITE_CREATE_VTABLE 29 /* Table Name Module Name */

#define	SQLITE_DROP_VTABLE 30 /* Table Name Module Name */

#define	SQLITE_FUNCTION 31 /* NULL Function Name */

#define	SQLITE_SAVEPOINT 32 /* Operation Savepoint Name */

#define	SQLITE_COPY 0 /* No longer used */

#define	SQLITE_RECURSIVE 33 /* NULL NULL */

#define	SQLITE_LIMIT_LENGTH 0

#define	SQLITE_LIMIT_SQL_LENGTH 1

#define	SQLITE_LIMIT_COLUMN 2

#define	SQLITE_LIMIT_EXPR_DEPTH 3

#define	SQLITE_LIMIT_COMPOUND_SELECT 4

#define	SQLITE_LIMIT_VDBE_OP 5

#define	SQLITE_LIMIT_FUNCTION_ARG 6

#define	SQLITE_LIMIT_ATTACHED 7

#define	SQLITE_LIMIT_LIKE_PATTERN_LENGTH 8

#define	SQLITE_LIMIT_VARIABLE_NUMBER 9

#define	SQLITE_LIMIT_TRIGGER_DEPTH 10

#define	SQLITE_LIMIT_WORKER_THREADS 11

#define	SQLITE_INTEGER 1

#define	SQLITE_FLOAT 2

#define	SQLITE_BLOB 4

#define	SQLITE_NULL 5

#define	SQLITE_TEXT 3

#define	SQLITE3_TEXT 3

#define	SQLITE_UTF8 1 /* IMP: R-37514-35566 */

#define	SQLITE_UTF16LE 2 /* IMP: R-03371-37637 */

#define	SQLITE_UTF16BE 3 /* IMP: R-51971-34154 */

#define	SQLITE_UTF16 4 /* Use native byte order */

#define	SQLITE_ANY 5 /* Deprecated */

#define	SQLITE_UTF16_ALIGNED 8 /* sqlite3_create_collation only */

#define	SQLITE_DETERMINISTIC 0x800

#define	SQLITE_STATIC ((sqlite3_destructor_type)0)

#define	SQLITE_TRANSIENT ((sqlite3_destructor_type)-1)

#define	SQLITE_INDEX_CONSTRAINT_EQ 2

#define	SQLITE_INDEX_CONSTRAINT_GT 4

#define	SQLITE_INDEX_CONSTRAINT_LE 8

#define	SQLITE_INDEX_CONSTRAINT_LT 16

#define	SQLITE_INDEX_CONSTRAINT_GE 32

#define	SQLITE_INDEX_CONSTRAINT_MATCH 64

#define	SQLITE_MUTEX_FAST 0

#define	SQLITE_MUTEX_RECURSIVE 1

#define	SQLITE_MUTEX_STATIC_MASTER 2

#define	SQLITE_MUTEX_STATIC_MEM 3 /* sqlite3_malloc() */

#define	SQLITE_MUTEX_STATIC_MEM2 4 /* NOT USED */

#define	SQLITE_MUTEX_STATIC_OPEN 4 /* sqlite3BtreeOpen() */

#define	SQLITE_MUTEX_STATIC_PRNG 5 /* sqlite3_random() */

#define	SQLITE_MUTEX_STATIC_LRU 6 /* lru page list */

#define	SQLITE_MUTEX_STATIC_LRU2 7 /* NOT USED */

#define	SQLITE_MUTEX_STATIC_PMEM 7 /* sqlite3PageMalloc() */

#define	SQLITE_MUTEX_STATIC_APP1 8 /* For use by application */

#define	SQLITE_MUTEX_STATIC_APP2 9 /* For use by application */

#define	SQLITE_MUTEX_STATIC_APP3 10 /* For use by application */

#define	SQLITE_TESTCTRL_FIRST 5

#define	SQLITE_TESTCTRL_PRNG_SAVE 5

#define	SQLITE_TESTCTRL_PRNG_RESTORE 6

#define	SQLITE_TESTCTRL_PRNG_RESET 7

#define	SQLITE_TESTCTRL_BITVEC_TEST 8

#define	SQLITE_TESTCTRL_FAULT_INSTALL 9

#define	SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS 10

#define	SQLITE_TESTCTRL_PENDING_BYTE 11

#define	SQLITE_TESTCTRL_ASSERT 12

#define	SQLITE_TESTCTRL_ALWAYS 13

#define	SQLITE_TESTCTRL_RESERVE 14

#define	SQLITE_TESTCTRL_OPTIMIZATIONS 15

#define	SQLITE_TESTCTRL_ISKEYWORD 16

#define	SQLITE_TESTCTRL_SCRATCHMALLOC 17

#define	SQLITE_TESTCTRL_LOCALTIME_FAULT 18

#define	SQLITE_TESTCTRL_EXPLAIN_STMT 19 /* NOT USED */

#define	SQLITE_TESTCTRL_NEVER_CORRUPT 20

#define	SQLITE_TESTCTRL_VDBE_COVERAGE 21

#define	SQLITE_TESTCTRL_BYTEORDER 22

#define	SQLITE_TESTCTRL_ISINIT 23

#define	SQLITE_TESTCTRL_SORTER_MMAP 24

#define	SQLITE_TESTCTRL_IMPOSTER 25

#define	SQLITE_TESTCTRL_LAST 25

#define	SQLITE_STATUS_MEMORY_USED 0

#define	SQLITE_STATUS_PAGECACHE_USED 1

#define	SQLITE_STATUS_PAGECACHE_OVERFLOW 2

#define	SQLITE_STATUS_SCRATCH_USED 3

#define	SQLITE_STATUS_SCRATCH_OVERFLOW 4

#define	SQLITE_STATUS_MALLOC_SIZE 5

#define	SQLITE_STATUS_PARSER_STACK 6

#define	SQLITE_STATUS_PAGECACHE_SIZE 7

#define	SQLITE_STATUS_SCRATCH_SIZE 8

#define	SQLITE_STATUS_MALLOC_COUNT 9

#define	SQLITE_DBSTATUS_LOOKASIDE_USED 0

#define	SQLITE_DBSTATUS_CACHE_USED 1

#define	SQLITE_DBSTATUS_SCHEMA_USED 2

#define	SQLITE_DBSTATUS_STMT_USED 3

#define	SQLITE_DBSTATUS_LOOKASIDE_HIT 4

#define	SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE 5

#define	SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL 6

#define	SQLITE_DBSTATUS_CACHE_HIT 7

#define	SQLITE_DBSTATUS_CACHE_MISS 8

#define	SQLITE_DBSTATUS_CACHE_WRITE 9

#define	SQLITE_DBSTATUS_DEFERRED_FKS 10

#define	SQLITE_DBSTATUS_MAX 10 /* Largest defined DBSTATUS */

#define	SQLITE_STMTSTATUS_FULLSCAN_STEP 1

#define	SQLITE_STMTSTATUS_SORT 2

#define	SQLITE_STMTSTATUS_AUTOINDEX 3

#define	SQLITE_STMTSTATUS_VM_STEP 4

#define	SQLITE_CHECKPOINT_PASSIVE 0 /* Do as much as possible w/o blocking */

#define	SQLITE_CHECKPOINT_FULL 1 /* Wait for writers, then checkpoint */

#define	SQLITE_CHECKPOINT_RESTART 2 /* Like FULL but wait for for readers */

#define	SQLITE_CHECKPOINT_TRUNCATE 3 /* Like RESTART but also truncate WAL */

#define	SQLITE_VTAB_CONSTRAINT_SUPPORT 1

#define	SQLITE_ROLLBACK 1

#define	SQLITE_FAIL 3

#define	SQLITE_REPLACE 5

#define	SQLITE_SCANSTAT_NLOOP 0

#define	SQLITE_SCANSTAT_NVISIT 1

#define	SQLITE_SCANSTAT_EST 2

#define	SQLITE_SCANSTAT_NAME 3

#define	SQLITE_SCANSTAT_EXPLAIN 4

#define	SQLITE_SCANSTAT_SELECTID 5

#define	_SQLITE3RTREE_H_

#define	NOT_WITHIN 0 /* Object completely outside of query region */

#define	PARTLY_WITHIN 1 /* Object partially overlaps query region */

#define	FULLY_WITHIN 2 /* Object fully contained within query region */

#define	SQLITE_MAX_LENGTH 1000000000

#define	SQLITE_MAX_COLUMN 2000

#define	SQLITE_MAX_SQL_LENGTH 1000000000

#define	SQLITE_MAX_EXPR_DEPTH 1000

#define	SQLITE_MAX_COMPOUND_SELECT 500

#define	SQLITE_MAX_VDBE_OP 25000

#define	SQLITE_MAX_FUNCTION_ARG 127

#define	SQLITE_DEFAULT_CACHE_SIZE 2000

#define	SQLITE_DEFAULT_WAL_AUTOCHECKPOINT 1000

#define	SQLITE_MAX_ATTACHED 10

#define	SQLITE_MAX_VARIABLE_NUMBER 999

#define	SQLITE_MAX_PAGE_SIZE 65536

#define	SQLITE_DEFAULT_PAGE_SIZE 1024

#define	SQLITE_MAX_DEFAULT_PAGE_SIZE 8192

#define	SQLITE_MAX_PAGE_COUNT 1073741823

#define	SQLITE_MAX_LIKE_PATTERN_LENGTH 50000

#define	SQLITE_MAX_TRIGGER_DEPTH 1000

#define	SQLITE_INT_TO_PTR(X) ((void)&((char)0)[X])

#define	SQLITE_PTR_TO_INT(X) ((int)(((char)X)-(char)0))

#define	SQLITE_NOINLINE

#define	SQLITE_THREADSAFE 1 /* IMP: R-07272-22309 */

#define	SQLITE_POWERSAFE_OVERWRITE 1

#define	SQLITE_DEFAULT_MEMSTATUS 1

#define	SQLITE_SYSTEM_MALLOC 1

#define	SQLITE_MALLOC_SOFT_LIMIT 1024

#define	_XOPEN_SOURCE 600

#define	NDEBUG 1

#define	testcase(X)

#define	TESTONLY(X)

#define	VVA_ONLY(X)

#define	ALWAYS(X) (X)

#define	NEVER(X) (X)

#define	IS_BIG_INT(X) (((X)&~(i64)0xffffffff)!=0)

#define	likely(X) (X)

#define	unlikely(X) (X)

#define	_SQLITE_HASH_H_

#define	sqliteHashFirst(H) ((H)->first)

#define	sqliteHashNext(E) ((E)->next)

#define	sqliteHashData(E) ((E)->data)

#define	TK_SEMI 1

#define	TK_EXPLAIN 2

#define	TK_QUERY 3

#define	TK_PLAN 4

#define	TK_BEGIN 5

#define	TK_TRANSACTION 6

#define	TK_DEFERRED 7

#define	TK_IMMEDIATE 8

#define	TK_EXCLUSIVE 9

#define	TK_COMMIT 10

#define	TK_END 11

#define	TK_ROLLBACK 12

#define	TK_SAVEPOINT 13

#define	TK_RELEASE 14

#define	TK_TO 15

#define	TK_TABLE 16

#define	TK_CREATE 17

#define	TK_IF 18

#define	TK_NOT 19

#define	TK_EXISTS 20

#define	TK_TEMP 21

#define	TK_LP 22

#define	TK_RP 23

#define	TK_AS 24

#define	TK_WITHOUT 25

#define	TK_COMMA 26

#define	TK_ID 27

#define	TK_INDEXED 28

#define	TK_ABORT 29

#define	TK_ACTION 30

#define	TK_AFTER 31

#define	TK_ANALYZE 32

#define	TK_ASC 33

#define	TK_ATTACH 34

#define	TK_BEFORE 35

#define	TK_BY 36

#define	TK_CASCADE 37

#define	TK_CAST 38

#define	TK_COLUMNKW 39

#define	TK_CONFLICT 40

#define	TK_DATABASE 41

#define	TK_DESC 42

#define	TK_DETACH 43

#define	TK_EACH 44

#define	TK_FAIL 45

#define	TK_FOR 46

#define	TK_IGNORE 47

#define	TK_INITIALLY 48

#define	TK_INSTEAD 49

#define	TK_LIKE_KW 50

#define	TK_MATCH 51

#define	TK_NO 52

#define	TK_KEY 53

#define	TK_OF 54

#define	TK_OFFSET 55

#define	TK_PRAGMA 56

#define	TK_RAISE 57

#define	TK_RECURSIVE 58

#define	TK_REPLACE 59

#define	TK_RESTRICT 60

#define	TK_ROW 61

#define	TK_TRIGGER 62

#define	TK_VACUUM 63

#define	TK_VIEW 64

#define	TK_VIRTUAL 65

#define	TK_WITH 66

#define	TK_REINDEX 67

#define	TK_RENAME 68

#define	TK_CTIME_KW 69

#define	TK_ANY 70

#define	TK_OR 71

#define	TK_AND 72

#define	TK_IS 73

#define	TK_BETWEEN 74

#define	TK_IN 75

#define	TK_ISNULL 76

#define	TK_NOTNULL 77

#define	TK_NE 78

#define	TK_EQ 79

#define	TK_GT 80

#define	TK_LE 81

#define	TK_LT 82

#define	TK_GE 83

#define	TK_ESCAPE 84

#define	TK_BITAND 85

#define	TK_BITOR 86

#define	TK_LSHIFT 87

#define	TK_RSHIFT 88

#define	TK_PLUS 89

#define	TK_MINUS 90

#define	TK_STAR 91

#define	TK_SLASH 92

#define	TK_REM 93

#define	TK_CONCAT 94

#define	TK_COLLATE 95

#define	TK_BITNOT 96

#define	TK_STRING 97

#define	TK_JOIN_KW 98

#define	TK_CONSTRAINT 99

#define	TK_DEFAULT 100

#define	TK_NULL 101

#define	TK_PRIMARY 102

#define	TK_UNIQUE 103

#define	TK_CHECK 104

#define	TK_REFERENCES 105

#define	TK_AUTOINCR 106

#define	TK_ON 107

#define	TK_INSERT 108

#define	TK_DELETE 109

#define	TK_UPDATE 110

#define	TK_SET 111

#define	TK_DEFERRABLE 112

#define	TK_FOREIGN 113

#define	TK_DROP 114

#define	TK_UNION 115

#define	TK_ALL 116

#define	TK_EXCEPT 117

#define	TK_INTERSECT 118

#define	TK_SELECT 119

#define	TK_VALUES 120

#define	TK_DISTINCT 121

#define	TK_DOT 122

#define	TK_FROM 123

#define	TK_JOIN 124

#define	TK_USING 125

#define	TK_ORDER 126

#define	TK_GROUP 127

#define	TK_HAVING 128

#define	TK_LIMIT 129

#define	TK_WHERE 130

#define	TK_INTO 131

#define	TK_INTEGER 132

#define	TK_FLOAT 133

#define	TK_BLOB 134

#define	TK_VARIABLE 135

#define	TK_CASE 136

#define	TK_WHEN 137

#define	TK_THEN 138

#define	TK_ELSE 139

#define	TK_INDEX 140

#define	TK_ALTER 141

#define	TK_ADD 142

#define	TK_TO_TEXT 143

#define	TK_TO_BLOB 144

#define	TK_TO_NUMERIC 145

#define	TK_TO_INT 146

#define	TK_TO_REAL 147

#define	TK_ISNOT 148

#define	TK_END_OF_FILE 149

#define	TK_ILLEGAL 150

#define	TK_SPACE 151

#define	TK_UNCLOSED_STRING 152

#define	TK_FUNCTION 153

#define	TK_COLUMN 154

#define	TK_AGG_FUNCTION 155

#define	TK_AGG_COLUMN 156

#define	TK_UMINUS 157

#define	TK_UPLUS 158

#define	TK_REGISTER 159

#define	SQLITE_BIG_DBL (1e99)

#define	OMIT_TEMPDB 0

#define	SQLITE_MAX_FILE_FORMAT 4

#define	SQLITE_DEFAULT_FILE_FORMAT 4

#define	SQLITE_DEFAULT_RECURSIVE_TRIGGERS 0

#define	SQLITE_TEMP_STORE 1

#define	SQLITE_TEMP_STORE_xc 1 /* Exclude from ctime.c */

#define	SQLITE_MAX_WORKER_THREADS 8

#define	SQLITE_DEFAULT_WORKER_THREADS 0

#define	offsetof(STRUCTURE, FIELD) ((int)((char)&((STRUCTURE)0)->FIELD))

#define	MIN(A, B) ((A)<(B)?(A):(B))

#define	MAX(A, B) ((A)>(B)?(A):(B))

#define	SWAP(TYPE, A, B) {TYPE t=A; A=B; B=t;}

#define	SQLITE_ASCII 1

#define	UINT32_TYPE unsigned int

#define	UINT16_TYPE unsigned short int

#define	INT16_TYPE short int

#define	UINT8_TYPE unsigned char

#define	INT8_TYPE signed char

#define	LONGDOUBLE_TYPE long double

#define	SQLITE_MAX_U32 ((((u64)1)<<32)-1)

#define	SQLITE_PTRSIZE 8

#define	SQLITE_BYTEORDER 0 /* 0 means "unknown at compile-time" */

#define	SQLITE_BIGENDIAN ((char )(&sqlite3one)==0)

#define	SQLITE_LITTLEENDIAN ((char )(&sqlite3one)==1)

#define	SQLITE_UTF16NATIVE (SQLITE_BIGENDIAN?SQLITE_UTF16BE:SQLITE_UTF16LE)

#define	LARGEST_INT64 (0xffffffff\|(((i64)0x7fffffff)<<32))

#define	SMALLEST_INT64 (((i64)-1) - LARGEST_INT64)

#define	ROUND8(x) (((x)+7)&~7)

#define	ROUNDDOWN8(x) ((x)&~7)

#define	EIGHT_BYTE_ALIGNMENT(X) ((((char)(X) - (char)0)&7)==0)

#define	SQLITE_MAX_MMAP_SIZE 0

#define	SQLITE_MAX_MMAP_SIZE_xc 1 /* exclude from ctime.c */

#define	SQLITE_DEFAULT_MMAP_SIZE 0

#define	SQLITE_DEFAULT_MMAP_SIZE_xc 1 /* Exclude from ctime.c */

#define	SELECTTRACE_ENABLED 0

#define	MASTER_NAME "sqlite_master"

#define	TEMP_MASTER_NAME "sqlite_temp_master"

#define	MASTER_ROOT 1

#define	SCHEMA_TABLE(x) ((!OMIT_TEMPDB)&&(x==1)?TEMP_MASTER_NAME:MASTER_NAME)

#define	ArraySize(X) ((int)(sizeof(X)/sizeof(X[0])))

#define	IsPowerOfTwo(X) (((X)&((X)-1))==0)

#define	SQLITE_DYNAMIC ((sqlite3_destructor_type)sqlite3MallocSize)

#define	SQLITE_WSD

#define	GLOBAL(t, v) v

#define	sqlite3GlobalConfig sqlite3Config

#define	UNUSED_PARAMETER(x) (void)(x)

#define	UNUSED_PARAMETER2(x, y) UNUSED_PARAMETER(x),UNUSED_PARAMETER(y)

#define	_BTREE_H_

#define	SQLITE_N_BTREE_META 16

#define	SQLITE_DEFAULT_AUTOVACUUM 0

#define	BTREE_AUTOVACUUM_NONE 0 /* Do not do auto-vacuum */

#define	BTREE_AUTOVACUUM_FULL 1 /* Do full auto-vacuum */

#define	BTREE_AUTOVACUUM_INCR 2 /* Incremental vacuum */

#define	BTREE_OMIT_JOURNAL 1 /* Do not create or use a rollback journal */

#define	BTREE_MEMORY 2 /* This is an in-memory DB */

#define	BTREE_SINGLE 4 /* The file contains at most 1 b-tree */

#define	BTREE_UNORDERED 8 /* Use of a hash implementation is OK */

#define	BTREE_INTKEY 1 /* Table has only 64-bit signed integer keys */

#define	BTREE_BLOBKEY 2 /* Table has keys only - no data */

#define	BTREE_FREE_PAGE_COUNT 0

#define	BTREE_SCHEMA_VERSION 1

#define	BTREE_FILE_FORMAT 2

#define	BTREE_DEFAULT_CACHE_SIZE 3

#define	BTREE_LARGEST_ROOT_PAGE 4

#define	BTREE_TEXT_ENCODING 5

#define	BTREE_USER_VERSION 6

#define	BTREE_INCR_VACUUM 7

#define	BTREE_APPLICATION_ID 8

#define	BTREE_DATA_VERSION 15 /* A virtual meta-value */

#define	BTREE_BULKLOAD 0x00000001 /* Used to full index in sorted order */

#define	BTREE_SEEK_EQ 0x00000002 /* EQ seeks only - no range seeks */

#define	_SQLITE_VDBE_H_

#define	P4_NOTUSED 0 /* The P4 parameter is not used */

#define	P4_DYNAMIC (-1) /* Pointer to a string obtained from sqliteMalloc() */

#define	P4_STATIC (-2) /* Pointer to a static string */

#define	P4_COLLSEQ (-4) /* P4 is a pointer to a CollSeq structure */

#define	P4_FUNCDEF (-5) /* P4 is a pointer to a FuncDef structure */

#define	P4_KEYINFO (-6) /* P4 is a pointer to a KeyInfo structure */

#define	P4_MEM (-8) /* P4 is a pointer to a Mem* structure */

#define	P4_TRANSIENT 0 /* P4 is a pointer to a transient string */

#define	P4_VTAB (-10) /* P4 is a pointer to an sqlite3_vtab structure */

#define	P4_MPRINTF (-11) /* P4 is a string obtained from sqlite3_mprintf() */

#define	P4_REAL (-12) /* P4 is a 64-bit floating point value */

#define	P4_INT64 (-13) /* P4 is a 64-bit signed integer */

#define	P4_INT32 (-14) /* P4 is a 32-bit signed integer */

#define	P4_INTARRAY (-15) /* P4 is a vector of 32-bit integers */

#define	P4_SUBPROGRAM (-18) /* P4 is a pointer to a SubProgram structure */

#define	P4_ADVANCE (-19) /* P4 is a pointer to BtreeNext() or BtreePrev() */

#define	P5_ConstraintNotNull 1

#define	P5_ConstraintUnique 2

#define	P5_ConstraintCheck 3

#define	P5_ConstraintFK 4

#define	COLNAME_NAME 0

#define	COLNAME_DECLTYPE 1

#define	COLNAME_DATABASE 2

#define	COLNAME_TABLE 3

#define	COLNAME_COLUMN 4

#define	COLNAME_N 2 /* Store the name and decltype */

#define	ADDR(X) (-1-(X))

#define	OP_Function 1 /* synopsis: r[P3]=func(r[P2@P5]) */

#define	OP_Savepoint 2

#define	OP_AutoCommit 3

#define	OP_Transaction 4

#define	OP_SorterNext 5

#define	OP_PrevIfOpen 6

#define	OP_NextIfOpen 7

#define	OP_Prev 8

#define	OP_Next 9

#define	OP_AggStep 10 /* synopsis: accum=r[P3] step(r[P2@P5]) */

#define	OP_Checkpoint 11

#define	OP_JournalMode 12

#define	OP_Vacuum 13

#define	OP_VFilter 14 /* synopsis: iplan=r[P3] zplan='P4' */

#define	OP_VUpdate 15 /* synopsis: data=r[P3@P2] */

#define	OP_Goto 16

#define	OP_Gosub 17

#define	OP_Return 18

#define	OP_Not 19 /* same as TK_NOT, synopsis: r[P2]= !r[P1] */

#define	OP_InitCoroutine 20

#define	OP_EndCoroutine 21

#define	OP_Yield 22

#define	OP_HaltIfNull 23 /* synopsis: if r[P3]=null halt */

#define	OP_Halt 24

#define	OP_Integer 25 /* synopsis: r[P2]=P1 */

#define	OP_Int64 26 /* synopsis: r[P2]=P4 */

#define	OP_String 27 /* synopsis: r[P2]='P4' (len=P1) */

#define	OP_Null 28 /* synopsis: r[P2..P3]=NULL */

#define	OP_SoftNull 29 /* synopsis: r[P1]=NULL */

#define	OP_Blob 30 /* synopsis: r[P2]=P4 (len=P1) */

#define	OP_Variable 31 /* synopsis: r[P2]=parameter(P1,P4) */

#define	OP_Move 32 /* synopsis: r[P2@P3]=r[P1@P3] */

#define	OP_Copy 33 /* synopsis: r[P2@P3+1]=r[P1@P3+1] */

#define	OP_SCopy 34 /* synopsis: r[P2]=r[P1] */

#define	OP_ResultRow 35 /* synopsis: output=r[P1@P2] */

#define	OP_CollSeq 36

#define	OP_AddImm 37 /* synopsis: r[P1]=r[P1]+P2 */

#define	OP_MustBeInt 38

#define	OP_RealAffinity 39

#define	OP_Cast 40 /* synopsis: affinity(r[P1]) */

#define	OP_Permutation 41

#define	OP_Compare 42 /* synopsis: r[P1@P3] <-> r[P2@P3] */

#define	OP_Jump 43

#define	OP_Once 44

#define	OP_If 45

#define	OP_IfNot 46

#define	OP_Column 47 /* synopsis: r[P3]=PX */

#define	OP_Affinity 48 /* synopsis: affinity(r[P1@P2]) */

#define	OP_MakeRecord 49 /* synopsis: r[P3]=mkrec(r[P1@P2]) */

#define	OP_Count 50 /* synopsis: r[P2]=count() */

#define	OP_ReadCookie 51

#define	OP_SetCookie 52

#define	OP_ReopenIdx 53 /* synopsis: root=P2 iDb=P3 */

#define	OP_OpenRead 54 /* synopsis: root=P2 iDb=P3 */

#define	OP_OpenWrite 55 /* synopsis: root=P2 iDb=P3 */

#define	OP_OpenAutoindex 56 /* synopsis: nColumn=P2 */

#define	OP_OpenEphemeral 57 /* synopsis: nColumn=P2 */

#define	OP_SorterOpen 58

#define	OP_SequenceTest 59 /* synopsis: if( cursor[P1].ctr++ ) pc = P2 */

#define	OP_OpenPseudo 60 /* synopsis: P3 columns in r[P2] */

#define	OP_Close 61

#define	OP_SeekLT 62 /* synopsis: key=r[P3@P4] */

#define	OP_SeekLE 63 /* synopsis: key=r[P3@P4] */

#define	OP_SeekGE 64 /* synopsis: key=r[P3@P4] */

#define	OP_SeekGT 65 /* synopsis: key=r[P3@P4] */

#define	OP_Seek 66 /* synopsis: intkey=r[P2] */

#define	OP_NoConflict 67 /* synopsis: key=r[P3@P4] */

#define	OP_NotFound 68 /* synopsis: key=r[P3@P4] */

#define	OP_Found 69 /* synopsis: key=r[P3@P4] */

#define	OP_NotExists 70 /* synopsis: intkey=r[P3] */

#define	OP_Or 71 /* same as TK_OR, synopsis: r[P3]=(r[P1] \|\| r[P2]) */

#define	OP_And 72 /* same as TK_AND, synopsis: r[P3]=(r[P1] && r[P2]) */

#define	OP_Sequence 73 /* synopsis: r[P2]=cursor[P1].ctr++ */

#define	OP_NewRowid 74 /* synopsis: r[P2]=rowid */

#define	OP_Insert 75 /* synopsis: intkey=r[P3] data=r[P2] */

#define	OP_IsNull 76 /* same as TK_ISNULL, synopsis: if r[P1]==NULL goto P2 */

#define	OP_NotNull 77 /* same as TK_NOTNULL, synopsis: if r[P1]!=NULL goto P2 */

#define	OP_Ne 78 /* same as TK_NE, synopsis: if r[P1]!=r[P3] goto P2 */

#define	OP_Eq 79 /* same as TK_EQ, synopsis: if r[P1]==r[P3] goto P2 */

#define	OP_Gt 80 /* same as TK_GT, synopsis: if r[P1]>r[P3] goto P2 */

#define	OP_Le 81 /* same as TK_LE, synopsis: if r[P1]<=r[P3] goto P2 */

#define	OP_Lt 82 /* same as TK_LT, synopsis: if r[P1]<r[P3] goto P2 */

#define	OP_Ge 83 /* same as TK_GE, synopsis: if r[P1]>=r[P3] goto P2 */

#define	OP_InsertInt 84 /* synopsis: intkey=P3 data=r[P2] */

#define	OP_BitAnd 85 /* same as TK_BITAND, synopsis: r[P3]=r[P1]&r[P2] */

#define	OP_BitOr 86 /* same as TK_BITOR, synopsis: r[P3]=r[P1]\|r[P2] */

#define	OP_ShiftLeft 87 /* same as TK_LSHIFT, synopsis: r[P3]=r[P2]<<r[P1] */

#define	OP_ShiftRight 88 /* same as TK_RSHIFT, synopsis: r[P3]=r[P2]>>r[P1] */

#define	OP_Add 89 /* same as TK_PLUS, synopsis: r[P3]=r[P1]+r[P2] */

#define	OP_Subtract 90 /* same as TK_MINUS, synopsis: r[P3]=r[P2]-r[P1] */

#define	OP_Multiply 91 /* same as TK_STAR, synopsis: r[P3]=r[P1]r[P2] /

#define	OP_Divide 92 /* same as TK_SLASH, synopsis: r[P3]=r[P2]/r[P1] */

#define	OP_Remainder 93 /* same as TK_REM, synopsis: r[P3]=r[P2]%r[P1] */

#define	OP_Concat 94 /* same as TK_CONCAT, synopsis: r[P3]=r[P2]+r[P1] */

#define	OP_Delete 95

#define	OP_BitNot 96 /* same as TK_BITNOT, synopsis: r[P1]= ~r[P1] */

#define	OP_String8 97 /* same as TK_STRING, synopsis: r[P2]='P4' */

#define	OP_ResetCount 98

#define	OP_SorterCompare 99 /* synopsis: if key(P1)!=trim(r[P3],P4) goto P2 */

#define	OP_SorterData 100 /* synopsis: r[P2]=data */

#define	OP_RowKey 101 /* synopsis: r[P2]=key */

#define	OP_RowData 102 /* synopsis: r[P2]=data */

#define	OP_Rowid 103 /* synopsis: r[P2]=rowid */

#define	OP_NullRow 104

#define	OP_Last 105

#define	OP_SorterSort 106

#define	OP_Sort 107

#define	OP_Rewind 108

#define	OP_SorterInsert 109

#define	OP_IdxInsert 110 /* synopsis: key=r[P2] */

#define	OP_IdxDelete 111 /* synopsis: key=r[P2@P3] */

#define	OP_IdxRowid 112 /* synopsis: r[P2]=rowid */

#define	OP_IdxLE 113 /* synopsis: key=r[P3@P4] */

#define	OP_IdxGT 114 /* synopsis: key=r[P3@P4] */

#define	OP_IdxLT 115 /* synopsis: key=r[P3@P4] */

#define	OP_IdxGE 116 /* synopsis: key=r[P3@P4] */

#define	OP_Destroy 117

#define	OP_Clear 118

#define	OP_ResetSorter 119

#define	OP_CreateIndex 120 /* synopsis: r[P2]=root iDb=P1 */

#define	OP_CreateTable 121 /* synopsis: r[P2]=root iDb=P1 */

#define	OP_ParseSchema 122

#define	OP_LoadAnalysis 123

#define	OP_DropTable 124

#define	OP_DropIndex 125

#define	OP_DropTrigger 126

#define	OP_IntegrityCk 127

#define	OP_RowSetAdd 128 /* synopsis: rowset(P1)=r[P2] */

#define	OP_RowSetRead 129 /* synopsis: r[P3]=rowset(P1) */

#define	OP_RowSetTest 130 /* synopsis: if r[P3] in rowset(P1) goto P2 */

#define	OP_Program 131

#define	OP_Param 132

#define	OP_Real 133 /* same as TK_FLOAT, synopsis: r[P2]=P4 */

#define	OP_FkCounter 134 /* synopsis: fkctr[P1]+=P2 */

#define	OP_FkIfZero 135 /* synopsis: if fkctr[P1]==0 goto P2 */

#define	OP_MemMax 136 /* synopsis: r[P1]=max(r[P1],r[P2]) */

#define	OP_IfPos 137 /* synopsis: if r[P1]>0 goto P2 */

#define	OP_IfNeg 138 /* synopsis: r[P1]+=P3, if r[P1]<0 goto P2 */

#define	OP_IfNotZero 139 /* synopsis: if r[P1]!=0 then r[P1]+=P3, goto P2 */

#define	OP_DecrJumpZero 140 /* synopsis: if (--r[P1])==0 goto P2 */

#define	OP_JumpZeroIncr 141 /* synopsis: if (r[P1]++)==0 ) goto P2 */

#define	OP_AggFinal 142 /* synopsis: accum=r[P1] N=P2 */

#define	OP_IncrVacuum 143

#define	OP_Expire 144

#define	OP_TableLock 145 /* synopsis: iDb=P1 root=P2 write=P3 */

#define	OP_VBegin 146

#define	OP_VCreate 147

#define	OP_VDestroy 148

#define	OP_VOpen 149

#define	OP_VColumn 150 /* synopsis: r[P3]=vcolumn(P2) */

#define	OP_VNext 151

#define	OP_VRename 152

#define	OP_Pagecount 153

#define	OP_MaxPgcnt 154

#define	OP_Init 155 /* synopsis: Start at P2 */

#define	OP_Noop 156

#define	OP_Explain 157

#define	OPFLG_JUMP 0x0001 /* jump: P2 holds jmp target */

#define	OPFLG_IN1 0x0002 /* in1: P1 is an input */

#define	OPFLG_IN2 0x0004 /* in2: P2 is an input */

#define	OPFLG_IN3 0x0008 /* in3: P3 is an input */

#define	OPFLG_OUT2 0x0010 /* out2: P2 is an output */

#define	OPFLG_OUT3 0x0020 /* out3: P3 is an output */

#define	OPFLG_INITIALIZER

#define	VdbeComment(X)

#define	VdbeNoopComment(X)

#define	VdbeModuleComment(X)

#define	VdbeCoverage(v)

#define	VdbeCoverageIf(v, x)

#define	VdbeCoverageAlwaysTaken(v)

#define	VdbeCoverageNeverTaken(v)

#define	VDBE_OFFSET_LINENO(x) 0

#define	sqlite3VdbeScanStatus(a, b, c, d, e)

#define	_PAGER_H_

#define	SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT -1

#define	PAGER_MJ_PGNO(x) ((Pgno)((PENDING_BYTE/((x)->pageSize))+1))

#define	PAGER_OMIT_JOURNAL 0x0001 /* Do not use a rollback journal */

#define	PAGER_MEMORY 0x0002 /* In-memory database */

#define	PAGER_LOCKINGMODE_QUERY -1

#define	PAGER_LOCKINGMODE_NORMAL 0

#define	PAGER_LOCKINGMODE_EXCLUSIVE 1

#define	PAGER_JOURNALMODE_QUERY (-1) /* Query the value of journalmode */

#define	PAGER_JOURNALMODE_DELETE 0 /* Commit by deleting journal file */

#define	PAGER_JOURNALMODE_PERSIST 1 /* Commit by zeroing journal header */

#define	PAGER_JOURNALMODE_OFF 2 /* Journal omitted. */

#define	PAGER_JOURNALMODE_TRUNCATE 3 /* Commit by truncating journal */

#define	PAGER_JOURNALMODE_MEMORY 4 /* In-memory journal file */

#define	PAGER_JOURNALMODE_WAL 5 /* Use write-ahead logging */

#define	PAGER_GET_NOCONTENT 0x01 /* Do not load data from disk */

#define	PAGER_GET_READONLY 0x02 /* Read-only page is acceptable */

#define	PAGER_SYNCHRONOUS_OFF 0x01 /* PRAGMA synchronous=OFF */

#define	PAGER_SYNCHRONOUS_NORMAL 0x02 /* PRAGMA synchronous=NORMAL */

#define	PAGER_SYNCHRONOUS_FULL 0x03 /* PRAGMA synchronous=FULL */

#define	PAGER_SYNCHRONOUS_MASK 0x03 /* Mask for three values above */

#define	PAGER_FULLFSYNC 0x04 /* PRAGMA fullfsync=ON */

#define	PAGER_CKPT_FULLFSYNC 0x08 /* PRAGMA checkpoint_fullfsync=ON */

#define	PAGER_CACHESPILL 0x10 /* PRAGMA cache_spill=ON */

#define	PAGER_FLAGS_MASK 0x1c /* All above except SYNCHRONOUS */

#define	sqlite3PagerGet(A, B, C) sqlite3PagerAcquire(A,B,C,0)

#define	disable_simulated_io_errors()

#define	enable_simulated_io_errors()

#define	PGHDR_DIRTY 0x002 /* Page has changed */

#define	PGHDR_NEED_SYNC

#define	PGHDR_NEED_READ 0x008 /* Content is unread */

#define	PGHDR_REUSE_UNLIKELY 0x010 /* A hint that reuse is unlikely */

#define	PGHDR_DONT_WRITE 0x020 /* Do not write content to disk */

#define	PGHDR_MMAP 0x040 /* This is an mmap page object */

#define	_SQLITE_OS_H_

#define	_OS_SETUP_H_

#define	SQLITE_OS_OTHER 0

#define	SQLITE_OS_WIN 0

#define	SQLITE_OS_UNIX 1

#define	SET_FULLSYNC(x, y)

#define	SQLITE_DEFAULT_SECTOR_SIZE 4096

#define	SQLITE_TEMP_FILE_PREFIX "etilqs_"

#define	NO_LOCK 0

#define	SHARED_LOCK 1

#define	RESERVED_LOCK 2

#define	PENDING_LOCK 3

#define	EXCLUSIVE_LOCK 4

#define	PENDING_BYTE sqlite3PendingByte

#define	RESERVED_BYTE (PENDING_BYTE+1)

#define	SHARED_FIRST (PENDING_BYTE+2)

#define	SHARED_SIZE 510

#define	SQLITE_FCNTL_DB_UNCHANGED 0xca093fa0

#define	SQLITE_MUTEX_PTHREADS

#define	MUTEX_LOGIC(X) X

#define	DbHasProperty(D, I, P) (((D)->aDb[I].pSchema->schemaFlags&(P))==(P))

#define	DbHasAnyProperty(D, I, P) (((D)->aDb[I].pSchema->schemaFlags&(P))!=0)

#define	DbSetProperty(D, I, P) (D)->aDb[I].pSchema->schemaFlags\|=(P)

#define	DbClearProperty(D, I, P) (D)->aDb[I].pSchema->schemaFlags&=~(P)

#define	DB_SchemaLoaded 0x0001 /* The schema has been loaded */

#define	DB_UnresetViews 0x0002 /* Some views have defined column names */

#define	DB_Empty 0x0004 /* The file is empty (length 0 bytes) */

#define	SQLITE_N_LIMIT (SQLITE_LIMIT_WORKER_THREADS+1)

#define	SCHEMA_ENC(db) ((db)->aDb[0].pSchema->enc)

#define	ENC(db) ((db)->enc)

#define	SQLITE_VdbeTrace 0x00000001 /* True to trace VDBE execution */

#define	SQLITE_InternChanges 0x00000002 /* Uncommitted Hash table changes */

#define	SQLITE_FullFSync 0x00000004 /* Use full fsync on the backend */

#define	SQLITE_CkptFullFSync 0x00000008 /* Use full fsync for checkpoint */

#define	SQLITE_CacheSpill 0x00000010 /* OK to spill pager cache */

#define	SQLITE_FullColNames 0x00000020 /* Show full column names on SELECT */

#define	SQLITE_ShortColNames 0x00000040 /* Show short columns names */

#define	SQLITE_CountRows 0x00000080 /* Count rows changed by INSERT, */

#define	SQLITE_NullCallback 0x00000100 /* Invoke the callback once if the */

#define	SQLITE_SqlTrace 0x00000200 /* Debug print SQL as it executes */

#define	SQLITE_VdbeListing 0x00000400 /* Debug listings of VDBE programs */

#define	SQLITE_WriteSchema 0x00000800 /* OK to update SQLITE_MASTER */

#define	SQLITE_VdbeAddopTrace 0x00001000 /* Trace sqlite3VdbeAddOp() calls */

#define	SQLITE_IgnoreChecks 0x00002000 /* Do not enforce check constraints */

#define	SQLITE_ReadUncommitted 0x0004000 /* For shared-cache mode */

#define	SQLITE_LegacyFileFmt 0x00008000 /* Create new databases in format 1 */

#define	SQLITE_RecoveryMode 0x00010000 /* Ignore schema errors */

#define	SQLITE_ReverseOrder 0x00020000 /* Reverse unordered SELECTs */

#define	SQLITE_RecTriggers 0x00040000 /* Enable recursive triggers */

#define	SQLITE_ForeignKeys 0x00080000 /* Enforce foreign key constraints */

#define	SQLITE_AutoIndex 0x00100000 /* Enable automatic indexes */

#define	SQLITE_PreferBuiltin 0x00200000 /* Preference to built-in funcs */

#define	SQLITE_LoadExtension 0x00400000 /* Enable load_extension */

#define	SQLITE_EnableTrigger 0x00800000 /* True to enable triggers */

#define	SQLITE_DeferFKs 0x01000000 /* Defer all FK constraints */

#define	SQLITE_QueryOnly 0x02000000 /* Disable database changes */

#define	SQLITE_VdbeEQP 0x04000000 /* Debug EXPLAIN QUERY PLAN */

#define	SQLITE_Vacuum 0x08000000 /* Currently in a VACUUM */

#define	SQLITE_QueryFlattener 0x0001 /* Query flattening */

#define	SQLITE_ColumnCache 0x0002 /* Column cache */

#define	SQLITE_GroupByOrder 0x0004 /* GROUPBY cover of ORDERBY */

#define	SQLITE_FactorOutConst 0x0008 /* Constant factoring */

#define	SQLITE_DistinctOpt 0x0020 /* DISTINCT using indexes */

#define	SQLITE_CoverIdxScan 0x0040 /* Covering index scans */

#define	SQLITE_OrderByIdxJoin 0x0080 /* ORDER BY of joins via index */

#define	SQLITE_SubqCoroutine 0x0100 /* Evaluate subqueries as coroutines */

#define	SQLITE_Transitive 0x0200 /* Transitive constraints */

#define	SQLITE_OmitNoopJoin 0x0400 /* Omit unused tables in joins */

#define	SQLITE_Stat34 0x0800 /* Use STAT3 or STAT4 data */

#define	SQLITE_AllOpts 0xffff /* All optimizations */

#define	OptimizationDisabled(db, mask) (((db)->dbOptFlags&(mask))!=0)

#define	OptimizationEnabled(db, mask) (((db)->dbOptFlags&(mask))==0)

#define	ConstFactorOk(P) ((P)->okConstFactor)

#define	SQLITE_MAGIC_OPEN 0xa029a697 /* Database is open */

#define	SQLITE_MAGIC_CLOSED 0x9f3c2d33 /* Database is closed */

#define	SQLITE_MAGIC_SICK 0x4b771290 /* Error and awaiting close */

#define	SQLITE_MAGIC_BUSY 0xf03b7906 /* Database currently in use */

#define	SQLITE_MAGIC_ERROR 0xb5357930 /* An SQLITE_MISUSE error occurred */

#define	SQLITE_MAGIC_ZOMBIE 0x64cffc7f /* Close with last statement close */

#define	SQLITE_FUNC_ENCMASK 0x003 /* SQLITE_UTF8, SQLITE_UTF16BE or UTF16LE */

#define	SQLITE_FUNC_LIKE 0x004 /* Candidate for the LIKE optimization */

#define	SQLITE_FUNC_CASE 0x008 /* Case-sensitive LIKE-type function */

#define	SQLITE_FUNC_EPHEM 0x010 /* Ephemeral. Delete with VDBE */

#define	SQLITE_FUNC_NEEDCOLL 0x020 /* sqlite3GetFuncCollSeq() might be called */

#define	SQLITE_FUNC_LENGTH 0x040 /* Built-in length() function */

#define	SQLITE_FUNC_TYPEOF 0x080 /* Built-in typeof() function */

#define	SQLITE_FUNC_COUNT 0x100 /* Built-in count() aggregate /

#define	SQLITE_FUNC_COALESCE 0x200 /* Built-in coalesce() or ifnull() */

#define	SQLITE_FUNC_UNLIKELY 0x400 /* Built-in unlikely() function */

#define	SQLITE_FUNC_CONSTANT 0x800 /* Constant inputs give a constant output */

#define	SQLITE_FUNC_MINMAX 0x1000 /* True for min() and max() aggregates */

#define	FUNCTION(zName, nArg, iArg, bNC, xFunc)

#define	VFUNCTION(zName, nArg, iArg, bNC, xFunc)

#define	FUNCTION2(zName, nArg, iArg, bNC, xFunc, extraFlags)

#define	STR_FUNCTION(zName, nArg, pArg, bNC, xFunc)

#define	LIKEFUNC(zName, nArg, arg, flags)

#define	AGGREGATE(zName, nArg, arg, nc, xStep, xFinal)

#define	AGGREGATE2(zName, nArg, arg, nc, xStep, xFinal, extraFlags)

#define	SAVEPOINT_BEGIN 0

#define	SAVEPOINT_RELEASE 1

#define	SAVEPOINT_ROLLBACK 2

#define	COLFLAG_PRIMKEY 0x0001 /* Column is part of the primary key */

#define	COLFLAG_HIDDEN 0x0002 /* A hidden column in a virtual table */

#define	SQLITE_SO_ASC 0 /* Sort in ascending order */

#define	SQLITE_SO_DESC 1 /* Sort in ascending order */

#define	SQLITE_AFF_NONE 'A'

#define	SQLITE_AFF_TEXT 'B'

#define	SQLITE_AFF_NUMERIC 'C'

#define	SQLITE_AFF_INTEGER 'D'

#define	SQLITE_AFF_REAL 'E'

#define	sqlite3IsNumericAffinity(X) ((X)>=SQLITE_AFF_NUMERIC)

#define	SQLITE_AFF_MASK 0x47

#define	SQLITE_JUMPIFNULL 0x10 /* jumps if either operand is NULL */

#define	SQLITE_STOREP2 0x20 /* Store result in reg[P2] rather than jump */

#define	SQLITE_NULLEQ 0x80 /* NULL=NULL */

#define	SQLITE_NOTNULL 0x90 /* Assert that operands are never NULL */

#define	TF_Readonly 0x01 /* Read-only system table */

#define	TF_Ephemeral 0x02 /* An ephemeral table */

#define	TF_HasPrimaryKey 0x04 /* Table has a primary key */

#define	TF_Autoincrement 0x08 /* Integer primary key is autoincrement */

#define	TF_Virtual 0x10 /* Is a virtual table */

#define	TF_WithoutRowid 0x20 /* No rowid used. PRIMARY KEY is the key */

#define	TF_OOOHidden 0x40 /* Out-of-Order hidden columns */

#define	IsVirtual(X) (((X)->tabFlags & TF_Virtual)!=0)

#define	IsHiddenColumn(X) (((X)->colFlags & COLFLAG_HIDDEN)!=0)

#define	HasRowid(X) (((X)->tabFlags & TF_WithoutRowid)==0)

#define	OE_None 0 /* There is no constraint to check */

#define	OE_Rollback 1 /* Fail the operation and rollback the transaction */

#define	OE_Abort 2 /* Back out changes but do no rollback transaction */

#define	OE_Fail 3 /* Stop the operation but leave all prior changes */

#define	OE_Ignore 4 /* Ignore the error. Do not do the INSERT or UPDATE */

#define	OE_Replace 5 /* Delete existing record, then do INSERT or UPDATE */

#define	OE_Restrict 6 /* OE_Abort for IMMEDIATE, OE_Rollback for DEFERRED */

#define	OE_SetNull 7 /* Set the foreign key value to NULL */

#define	OE_SetDflt 8 /* Set the foreign key value to its default */

#define	OE_Cascade 9 /* Cascade the changes */

#define	OE_Default 10 /* Do whatever the default action is */

#define	SQLITE_IDXTYPE_APPDEF 0 /* Created using CREATE INDEX */

#define	SQLITE_IDXTYPE_UNIQUE 1 /* Implements a UNIQUE constraint */

#define	SQLITE_IDXTYPE_PRIMARYKEY 2 /* Is the PRIMARY KEY for the table */

#define	IsPrimaryKeyIndex(X) ((X)->idxType==SQLITE_IDXTYPE_PRIMARYKEY)

#define	IsUniqueIndex(X) ((X)->onError!=OE_None)

#define	EP_FromJoin 0x000001 /* Originates in ON/USING clause of outer join */

#define	EP_Agg 0x000002 /* Contains one or more aggregate functions */

#define	EP_Resolved 0x000004 /* IDs have been resolved to COLUMNs */

#define	EP_Error 0x000008 /* Expression contains one or more errors */

#define	EP_Distinct 0x000010 /* Aggregate function with DISTINCT keyword */

#define	EP_VarSelect 0x000020 /* pSelect is correlated, not constant */

#define	EP_DblQuoted 0x000040 /* token.z was originally in "..." */

#define	EP_InfixFunc 0x000080 /* True for an infix function: LIKE, GLOB, etc */

#define	EP_Collate 0x000100 /* Tree contains a TK_COLLATE operator */

#define	EP_Generic 0x000200 /* Ignore COLLATE or affinity on this tree */

#define	EP_IntValue 0x000400 /* Integer value contained in u.iValue */

#define	EP_xIsSelect 0x000800 /* x.pSelect is valid (otherwise x.pList is) */

#define	EP_Skip 0x001000 /* COLLATE, AS, or UNLIKELY */

#define	EP_Reduced 0x002000 /* Expr struct EXPR_REDUCEDSIZE bytes only */

#define	EP_TokenOnly 0x004000 /* Expr struct EXPR_TOKENONLYSIZE bytes only */

#define	EP_Static 0x008000 /* Held in memory not obtained from malloc() */

#define	EP_MemToken 0x010000 /* Need to sqlite3DbFree() Expr.zToken */

#define	EP_NoReduce 0x020000 /* Cannot EXPRDUP_REDUCE this Expr */

#define	EP_Unlikely 0x040000 /* unlikely() or likelihood() function */

#define	EP_ConstFunc 0x080000 /* Node is a SQLITE_FUNC_CONSTANT function */

#define	EP_CanBeNull 0x100000 /* Can be null despite NOT NULL constraint */

#define	EP_Subquery 0x200000 /* Tree contains a TK_SELECT operator */

#define	EP_Propagate (EP_Collate\|EP_Subquery) /* Propagate these bits up tree */

#define	ExprHasProperty(E, P) (((E)->flags&(P))!=0)

#define	ExprHasAllProperty(E, P) (((E)->flags&(P))==(P))

#define	ExprSetProperty(E, P) (E)->flags\|=(P)

#define	ExprClearProperty(E, P) (E)->flags&=~(P)

#define	ExprSetVVAProperty(E, P)

#define	EXPR_FULLSIZE sizeof(Expr) /* Full size */

#define	EXPR_REDUCEDSIZE offsetof(Expr,iTable) /* Common features */

#define	EXPR_TOKENONLYSIZE offsetof(Expr,pLeft) /* Fewer features */

#define	EXPRDUP_REDUCE 0x0001 /* Used reduced-size Expr nodes */

#define	BMS ((int)(sizeof(Bitmask)*8))

#define	MASKBIT(n) (((Bitmask)1)<<(n))

#define	MASKBIT32(n) (((unsigned int)1)<<(n))

#define	JT_INNER 0x0001 /* Any kind of inner or cross join */

#define	JT_CROSS 0x0002 /* Explicit use of the CROSS keyword */

#define	JT_NATURAL 0x0004 /* True for a "natural" join */

#define	JT_LEFT 0x0008 /* Left outer join */

#define	JT_RIGHT 0x0010 /* Right outer join */

#define	JT_OUTER 0x0020 /* The "OUTER" keyword is present */

#define	JT_ERROR 0x0040 /* unknown or unsupported join type */

#define	WHERE_ORDERBY_NORMAL 0x0000 /* No-op */

#define	WHERE_ORDERBY_MIN 0x0001 /* ORDER BY processing for min() func */

#define	WHERE_ORDERBY_MAX 0x0002 /* ORDER BY processing for max() func */

#define	WHERE_ONEPASS_DESIRED 0x0004 /* Want to do one-pass UPDATE/DELETE */

#define	WHERE_DUPLICATES_OK 0x0008 /* Ok to return a row more than once */

#define	WHERE_OMIT_OPEN_CLOSE 0x0010 /* Table cursors are already open */

#define	WHERE_FORCE_TABLE 0x0020 /* Do not use an index-only search */

#define	WHERE_ONETABLE_ONLY 0x0040 /* Only code the 1st table in pTabList */

#define	WHERE_NO_AUTOINDEX 0x0080 /* Disallow automatic indexes */

#define	WHERE_GROUPBY 0x0100 /* pOrderBy is really a GROUP BY */

#define	WHERE_DISTINCTBY 0x0200 /* pOrderby is really a DISTINCT clause */

#define	WHERE_WANT_DISTINCT 0x0400 /* All output needs to be distinct */

#define	WHERE_SORTBYGROUP 0x0800 /* Support sqlite3WhereIsSorted() */

#define	WHERE_REOPEN_IDX 0x1000 /* Try to use OP_ReopenIdx */

#define	WHERE_DISTINCT_NOOP 0 /* DISTINCT keyword not used */

#define	WHERE_DISTINCT_UNIQUE 1 /* No duplicates */

#define	WHERE_DISTINCT_ORDERED 2 /* All duplicates are adjacent */

#define	WHERE_DISTINCT_UNORDERED 3 /* Duplicates are scattered */

#define	NC_AllowAgg 0x0001 /* Aggregate functions are allowed here */

#define	NC_HasAgg 0x0002 /* One or more aggregate functions seen */

#define	NC_IsCheck 0x0004 /* True if resolving names in a CHECK constraint */

#define	NC_InAggFunc 0x0008 /* True if analyzing arguments to an agg func */

#define	NC_PartIdx 0x0010 /* True if resolving a partial index WHERE */

#define	NC_MinMaxAgg 0x1000 /* min/max aggregates seen. See note above */

#define	SF_Distinct 0x0001 /* Output should be DISTINCT */

#define	SF_Resolved 0x0002 /* Identifiers have been resolved */

#define	SF_Aggregate 0x0004 /* Contains aggregate functions */

#define	SF_UsesEphemeral 0x0008 /* Uses the OpenEphemeral opcode */

#define	SF_Expanded 0x0010 /* sqlite3SelectExpand() called on this */

#define	SF_HasTypeInfo 0x0020 /* FROM subqueries have Table metadata */

#define	SF_Compound 0x0040 /* Part of a compound query */

#define	SF_Values 0x0080 /* Synthesized from VALUES clause */

#define	SF_MultiValue 0x0100 /* Single VALUES term with multiple rows */

#define	SF_NestedFrom 0x0200 /* Part of a parenthesized FROM clause */

#define	SF_MaybeConvert 0x0400 /* Need convertCompoundSelectToSubquery() */

#define	SF_Recursive 0x0800 /* The recursive part of a recursive CTE */

#define	SF_MinMaxAgg 0x1000 /* Aggregate containing min() or max() */

#define	SF_Converted 0x2000 /* By convertCompoundSelectToSubquery() */

#define	SRT_Union 1 /* Store result as keys in an index */

#define	SRT_Except 2 /* Remove result from a UNION index */

#define	SRT_Exists 3 /* Store 1 if the result is not empty */

#define	SRT_Discard 4 /* Do not save the results anywhere */

#define	SRT_Fifo 5 /* Store result as data with an automatic rowid */

#define	SRT_DistFifo 6 /* Like SRT_Fifo, but unique results only */

#define	SRT_Queue 7 /* Store result in an queue */

#define	SRT_DistQueue 8 /* Like SRT_Queue, but unique results only */

#define	IgnorableOrderby(X) ((X->eDest)<=SRT_DistQueue)

#define	SRT_Output 9 /* Output each row of result */

#define	SRT_Mem 10 /* Store result in a memory cell */

#define	SRT_Set 11 /* Store results as keys in an index */

#define	SRT_EphemTab 12 /* Create transient tab and store like SRT_Table */

#define	SRT_Coroutine 13 /* Generate a single row of result */

#define	SRT_Table 14 /* Store result as data with an automatic rowid */

#define	SQLITE_N_COLCACHE 10

#define	DbMaskTest(M, I) (((M)&(((yDbMask)1)<<(I)))!=0)

#define	DbMaskZero(M) (M)=0

#define	DbMaskSet(M, I) (M)\|=(((yDbMask)1)<<(I))

#define	DbMaskAllZero(M) (M)==0

#define	DbMaskNonZero(M) (M)!=0

#define	IN_DECLARE_VTAB (pParse->declareVtab)

#define	OPFLAG_NCHANGE 0x01 /* Set to update db->nChange */

#define	OPFLAG_EPHEM 0x01 /* OP_Column: Ephemeral output is ok */

#define	OPFLAG_LASTROWID 0x02 /* Set to update db->lastRowid */

#define	OPFLAG_ISUPDATE 0x04 /* This OP_Insert is an sql UPDATE */

#define	OPFLAG_APPEND 0x08 /* This is likely to be an append */

#define	OPFLAG_USESEEKRESULT 0x10 /* Try to avoid a seek in BtreeInsert() */

#define	OPFLAG_LENGTHARG 0x40 /* OP_Column only used for length() */

#define	OPFLAG_TYPEOFARG 0x80 /* OP_Column only used for typeof() */

#define	OPFLAG_BULKCSR 0x01 /* OP_Open** used to open bulk cursor */

#define	OPFLAG_SEEKEQ 0x02 /* OP_Open** cursor uses EQ seek only */

#define	OPFLAG_P2ISREG 0x04 /* P2 to OP_Open** is a register number */

#define	OPFLAG_PERMUTE 0x01 /* OP_Compare: use the permutation */

#define	TRIGGER_BEFORE 1

#define	TRIGGER_AFTER 2

#define	STRACCUM_NOMEM 1

#define	STRACCUM_TOOBIG 2

#define	CORRUPT_DB (sqlite3Config.neverCorrupt==0)

#define	WRC_Continue 0 /* Continue down into children */

#define	WRC_Prune 1 /* Omit children but continue walking siblings */

#define	WRC_Abort 2 /* Abandon the tree walk */

#define	SQLITE_SKIP_UTF8(zIn)

#define	SQLITE_CORRUPT_BKPT sqlite3CorruptError(__LINE__)

#define	SQLITE_MISUSE_BKPT sqlite3MisuseError(__LINE__)

#define	SQLITE_CANTOPEN_BKPT sqlite3CantopenError(__LINE__)

#define	sqlite3Toupper(x) ((x)&~(sqlite3CtypeMap[(unsigned char)(x)]&0x20))

#define	sqlite3Isspace(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x01)

#define	sqlite3Isalnum(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x06)

#define	sqlite3Isalpha(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x02)

#define	sqlite3Isdigit(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x04)

#define	sqlite3Isxdigit(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x08)

#define	sqlite3Tolower(x) (sqlite3UpperToLower[(unsigned char)(x)])

#define	sqlite3StrICmp sqlite3_stricmp

#define	sqlite3StrNICmp sqlite3_strnicmp

#define	sqlite3StackAllocRaw(D, N) sqlite3DbMallocRaw(D,N)

#define	sqlite3StackAllocZero(D, N) sqlite3DbMallocZero(D,N)

#define	sqlite3StackFree(D, P) sqlite3DbFree(D,P)

#define	SQLITE_PRINTF_INTERNAL 0x01

#define	SQLITE_PRINTF_SQLFUNC 0x02

#define	SQLITE_ECEL_DUP 0x01 /* Deep, not shallow copies */

#define	SQLITE_ECEL_FACTOR 0x02 /* Factor out constant terms */

#define	sqlite3SelectSetName(A, B)

#define	sqlite3ParseToplevel(p) ((p)->pToplevel ? (p)->pToplevel : (p))

#define	getVarint32(A, B) (u8)(((A)<(u8)0x80)?((B)=(u32)(A)),1:sqlite3GetVarint32((A),(u32 *)&(B)))

#define	putVarint32(A, B)

#define	getVarint sqlite3GetVarint

#define	putVarint sqlite3PutVarint

#define	sqlite3FileSuffix3(X, Y)

#define	sqlite3VtabInSync(db) ((db)->nVTrans>0 && (db)->aVTrans==0)

#define	SQLITE_FAULTINJECTOR_MALLOC 0

#define	SQLITE_FAULTINJECTOR_COUNT 1

#define	IN_INDEX_ROWID 1 /* Search the rowid of the table */

#define	IN_INDEX_EPH 2 /* Search an ephemeral b-tree */

#define	IN_INDEX_INDEX_ASC 3 /* Existing index ASCENDING */

#define	IN_INDEX_INDEX_DESC 4 /* Existing index DESCENDING */

#define	IN_INDEX_NOOP 5 /* No table available. Use comparisons */

#define	IN_INDEX_NOOP_OK 0x0001 /* OK to return IN_INDEX_NOOP */

#define	IN_INDEX_MEMBERSHIP 0x0002 /* IN operator used for membership test */

#define	IN_INDEX_LOOP 0x0004 /* IN operator used as a loop */

#define	sqlite3JournalSize(pVfs) ((pVfs)->szOsFile)

#define	sqlite3JournalExists(p) 1

#define	sqlite3ConnectionBlocked(x, y)

#define	sqlite3ConnectionUnlocked(x)

#define	sqlite3ConnectionClosed(x)

#define	IOTRACE(A)

#define	sqlite3VdbeIOTraceSql(X)

#define	sqlite3MemdebugSetType(X, Y) /* no-op */

#define	sqlite3MemdebugHasType(X, Y) 1

#define	sqlite3MemdebugNoType(X, Y) 1

#define	MEMTYPE_HEAP 0x01 /* General heap allocations */

#define	MEMTYPE_LOOKASIDE 0x02 /* Heap that might have been lookaside */

#define	MEMTYPE_SCRATCH 0x04 /* Scratch allocations */

#define	MEMTYPE_PCACHE 0x08 /* Page cache allocations */

#define	SQLITE_USE_URI 0

#define	SQLITE_ALLOW_COVERING_INDEX_SCAN 1

#define	SQLITE_SORTER_PMASZ 250

#define	CTIMEOPT_VAL_(opt) #opt

#define	CTIMEOPT_VAL(opt) CTIMEOPT_VAL_(opt)

#define	_VDBEINT_H_

#define	SQLITE_MAX_SCHEMA_RETRY 50

#define	VdbeFrameMem(p) ((Mem )&((u8 )p)[ROUND8(sizeof(VdbeFrame))])

#define	CACHE_STALE 0

#define	MEM_Null 0x0001 /* Value is NULL */

#define	MEM_Str 0x0002 /* Value is a string */

#define	MEM_Int 0x0004 /* Value is an integer */

#define	MEM_Real 0x0008 /* Value is a real number */

#define	MEM_Blob 0x0010 /* Value is a BLOB */

#define	MEM_AffMask 0x001f /* Mask of affinity bits */

#define	MEM_RowSet 0x0020 /* Value is a RowSet object */

#define	MEM_Frame 0x0040 /* Value is a VdbeFrame object */

#define	MEM_Undefined 0x0080 /* Value is undefined */

#define	MEM_Cleared 0x0100 /* NULL set by OP_Null, not from data */

#define	MEM_TypeMask 0x01ff /* Mask of type bits */

#define	MEM_Term 0x0200 /* String rep is nul terminated */

#define	MEM_Dyn 0x0400 /* Need to call Mem.xDel() on Mem.z */

#define	MEM_Static 0x0800 /* Mem.z points to a static string */

#define	MEM_Ephem 0x1000 /* Mem.z points to an ephemeral string */

#define	MEM_Agg 0x2000 /* Mem.z points to an agg function context */

#define	MEM_Zero 0x4000 /* Mem.i contains count of 0s appended to blob */

#define	MemSetTypeFlag(p, f) ((p)->flags = ((p)->flags&~(MEM_TypeMask\|MEM_Zero))\|f)

#define	VDBE_MAGIC_INIT 0x26bceaa5 /* Building a VDBE program */

#define	VDBE_MAGIC_RUN 0xbdf20da3 /* VDBE is ready to execute */

#define	VDBE_MAGIC_HALT 0x519c2973 /* VDBE has completed execution */

#define	VDBE_MAGIC_DEAD 0xb606c3c8 /* The VDBE has been deallocated */

#define	VdbeMemDynamic(X) (((X)->flags&(MEM_Agg\|MEM_Dyn\|MEM_RowSet\|MEM_Frame))!=0)

#define	ExpandBlob(P) (((P)->flags&MEM_Zero)?sqlite3VdbeMemExpandBlob(P):0)

#define	wsdStatInit

#define	wsdStat sqlite3Stat

#define	_SQLITE_OS_C_ 1

#define	DO_OS_MALLOC_TEST(x)

#define	vfsList GLOBAL(sqlite3_vfs *, vfsList)

#define	wsdHooksInit

#define	wsdHooks sqlite3Hooks

#define	SQLITE_MALLOC(x) malloc(x)

#define	SQLITE_FREE(x) free(x)

#define	SQLITE_REALLOC(x, y) realloc((x),(y))

#define	SQLITE_MUTEX_NREF 0

#define	SQLITE3_MUTEX_INITIALIZER { PTHREAD_MUTEX_INITIALIZER }

#define	mem0 GLOBAL(struct Mem0Global, mem0)

#define	etRADIX 1 /* Integer types. %d, %x, %o, and so forth */

#define	etFLOAT 2 /* Floating point. %f */

#define	etEXP 3 /* Exponentional notation. %e and %E */

#define	etGENERIC 4 /* Floating or exponential, depending on exponent. %g */

#define	etSIZE 5 /* Return number of characters processed so far. %n */

#define	etSTRING 6 /* Strings. %s */

#define	etDYNSTRING 7 /* Dynamically allocated strings. %z */

#define	etPERCENT 8 /* Percent symbol. %% */

#define	etCHARX 9 /* Characters. %c */

#define	etSQLESCAPE 10 /* Strings with '\'' doubled. %q */

#define	etSQLESCAPE2

#define	etTOKEN 12 /* a pointer to a Token structure */

#define	etSRCLIST 13 /* a pointer to a SrcList */

#define	etPOINTER 14 /* The %p conversion */

#define	etSQLESCAPE3 15 /* %w -> Strings with '\"' doubled */

#define	etORDINAL 16 /* %r -> 1st, 2nd, 3rd, 4th, etc. English only */

#define	etINVALID 0 /* Any unrecognized conversion type */

#define	FLAG_SIGNED 1 /* True if the value to convert is signed */

#define	FLAG_INTERN 2 /* True if for internal use only */

#define	FLAG_STRING 4 /* Allow infinity precision */

#define	SQLITE_PRINT_BUF_SIZE 70

#define	etBUFSIZE SQLITE_PRINT_BUF_SIZE /* Size of the output buffer */

#define	wsdPrng sqlite3Prng

#define	SQLITE_THREADS_IMPLEMENTED 1 /* Prevent the single-thread code below */

#define	WRITE_UTF8(zOut, c)

#define	WRITE_UTF16LE(zOut, c)

#define	WRITE_UTF16BE(zOut, c)

#define	READ_UTF16LE(zIn, TERM, c)

#define	READ_UTF16BE(zIn, TERM, c)

#define	READ_UTF8(zIn, zTerm, c)

#define	UpperToLower sqlite3UpperToLower

#define	SLOT_2_0 0x001fc07f

#define	SLOT_4_2_0 0xf01fc07f

#define	TWOPOWER32 (((i64)1)<<32)

#define	TWOPOWER31 (((i64)1)<<31)

#define	OpHelp(X)

#define	SQLITE_ENABLE_LOCKING_STYLE 0

#define	SQLITE_FSFLAGS_IS_MSDOS 0x1

#define	SQLITE_UNIX_THREADS 1

#define	SQLITE_DEFAULT_FILE_PERMISSIONS 0644

#define	SQLITE_DEFAULT_PROXYDIR_PERMISSIONS 0755

#define	MAX_PATHNAME 512

#define	osGetpid(X) (pid_t)getpid()

#define	IS_LOCK_ERROR(x) ((x != SQLITE_OK) && (x != SQLITE_BUSY))

#define	UNIXFILE_EXCL 0x01 /* Connections from one process only */

#define	UNIXFILE_RDONLY 0x02 /* Connection is read only */

#define	UNIXFILE_PERSIST_WAL 0x04 /* Persistent WAL mode */

#define	UNIXFILE_DIRSYNC 0x08 /* Directory sync needed */

#define	UNIXFILE_PSOW 0x10 /* SQLITE_IOCAP_POWERSAFE_OVERWRITE */

#define	UNIXFILE_DELETE 0x20 /* Delete on close */

#define	UNIXFILE_URI 0x40 /* Filename might have query parameters */

#define	UNIXFILE_NOLOCK 0x80 /* Do no file locking */

#define	UNIXFILE_WARNED 0x0100 /* verifyDbFile() warnings issued */

#define	UNIXFILE_BLOCK 0x0200 /* Next SHM lock might block */

#define	_OS_COMMON_H_

#define	OSTRACE(X)

#define	TIMER_START

#define	TIMER_END

#define	TIMER_ELAPSED ((sqlite_uint64)0)

#define	SimulateIOErrorBenign(X)

#define	SimulateIOError(A)

#define	SimulateDiskfullError(A)

#define	OpenCounter(X)

#define	O_LARGEFILE 0

#define	O_NOFOLLOW 0

#define	O_BINARY 0

#define	threadid pthread_self()

#define	HAVE_MREMAP 0

#define	osOpen ((int()(const char,int,int))aSyscall[0].pCurrent)

#define	osClose ((int(*)(int))aSyscall[1].pCurrent)

#define	osAccess ((int()(const char,int))aSyscall[2].pCurrent)

#define	osGetcwd ((char()(char*,size_t))aSyscall[3].pCurrent)

#define	osStat ((int()(const char,struct stat*))aSyscall[4].pCurrent)

#define	osFstat ((int()(int,struct stat))aSyscall[5].pCurrent)

#define	osFtruncate ((int(*)(int,off_t))aSyscall[6].pCurrent)

#define	osFcntl ((int(*)(int,int,...))aSyscall[7].pCurrent)

#define	osRead ((ssize_t()(int,void,size_t))aSyscall[8].pCurrent)

#define	osPread ((ssize_t()(int,void,size_t,off_t))aSyscall[9].pCurrent)

#define	osPread64 ((ssize_t()(int,void,size_t,off_t))aSyscall[10].pCurrent)

#define	osWrite ((ssize_t()(int,const void,size_t))aSyscall[11].pCurrent)

#define	osPwrite

#define	osPwrite64

#define	osFchmod ((int(*)(int,mode_t))aSyscall[14].pCurrent)

#define	osFallocate ((int(*)(int,off_t,off_t))aSyscall[15].pCurrent)

#define	osUnlink ((int()(const char))aSyscall[16].pCurrent)

#define	osOpenDirectory ((int()(const char,int*))aSyscall[17].pCurrent)

#define	osMkdir ((int()(const char,mode_t))aSyscall[18].pCurrent)

#define	osRmdir ((int()(const char))aSyscall[19].pCurrent)

#define	osFchown ((int(*)(int,uid_t,gid_t))aSyscall[20].pCurrent)

#define	osMmap ((void()(void*,size_t,int,int,int,off_t))aSyscall[21].pCurrent)

#define	osMunmap ((void()(void*,size_t))aSyscall[22].pCurrent)

#define	osMremap ((void()(void*,size_t,size_t,int,...))aSyscall[23].pCurrent)

#define	osGetpagesize ((int(*)(void))aSyscall[24].pCurrent)

#define	SQLITE_MINIMUM_FILE_DESCRIPTOR 3

#define	unixLogError(a, b, c) unixLogErrorAtLine(a,b,c,__LINE__)

#define	DOTLOCK_SUFFIX ".lock"

#define	fdatasync fsync

#define	HAVE_FULLFSYNC 0

#define	UNIX_SHM_BASE ((22+SQLITE_SHM_NLOCK)4) / first lock byte */

#define	UNIX_SHM_DMS (UNIX_SHM_BASE+SQLITE_SHM_NLOCK) /* deadman switch */

#define	IOMETHODS(FINDER, METHOD, VERSION, CLOSE, LOCK, UNLOCK, CKLOCK, SHMMAP)

#define	UNIXVFS(VFSNAME, FINDER)

#define	BITVEC_SZ 512

#define	BITVEC_USIZE (((BITVEC_SZ-(3sizeof(u32)))/sizeof(Bitvec))sizeof(Bitvec))

#define	BITVEC_TELEM u8

#define	BITVEC_SZELEM 8

#define	BITVEC_NELEM (BITVEC_USIZE/sizeof(BITVEC_TELEM))

#define	BITVEC_NBIT (BITVEC_NELEM*BITVEC_SZELEM)

#define	BITVEC_NINT (BITVEC_USIZE/sizeof(u32))

#define	BITVEC_MXHASH (BITVEC_NINT/2)

#define	BITVEC_HASH(X) (((X)*1)%BITVEC_NINT)

#define	BITVEC_NPTR (BITVEC_USIZE/sizeof(Bitvec *))

#define	SETBIT(V, I) V[I>>3] \|= (1<<(I&7))

#define	CLEARBIT(V, I) V[I>>3] &= ~(1<<(I&7))

#define	TESTBIT(V, I) (V[I>>3]&(1<<(I&7)))!=0

#define	PCACHE_DIRTYLIST_REMOVE 1 /* Remove pPage from dirty list */

#define	PCACHE_DIRTYLIST_ADD 2 /* Add pPage to the dirty list */

#define	PCACHE_DIRTYLIST_FRONT 3 /* Move pPage to the front of the list */

#define	N_SORT_BUCKET 32

#define	pcache1 (GLOBAL(struct PCacheGlobal, pcache1_g))

#define	pcache1EnterMutex(X) sqlite3_mutex_enter((X)->mutex)

#define	pcache1LeaveMutex(X) sqlite3_mutex_leave((X)->mutex)

#define	ROWSET_ALLOCATION_SIZE 1024

#define	ROWSET_ENTRY_PER_CHUNK ((ROWSET_ALLOCATION_SIZE-8)/sizeof(struct RowSetEntry))

#define	ROWSET_SORTED 0x01 /* True if RowSet.pEntry is sorted */

#define	ROWSET_NEXT 0x02 /* True if sqlite3RowSetNext() has been called */

#define	_WAL_H_

#define	WAL_SYNC_TRANSACTIONS 0x20 /* Sync at the end of each transaction */

#define	SQLITE_SYNC_MASK 0x13 /* Mask off the SQLITE_SYNC_* values */

#define	WAL_SAVEPOINT_NDATA 4

#define	PAGERTRACE(X)

#define	PAGERID(p) ((int)(p->fd))

#define	FILEHANDLEID(fd) ((int)fd)

#define	PAGER_OPEN 0

#define	PAGER_READER 1

#define	PAGER_WRITER_LOCKED 2

#define	PAGER_WRITER_CACHEMOD 3

#define	PAGER_WRITER_DBMOD 4

#define	PAGER_WRITER_FINISHED 5

#define	PAGER_ERROR 6

#define	UNKNOWN_LOCK (EXCLUSIVE_LOCK+1)

#define	CODEC1(P, D, N, X, E) /* NO-OP */

#define	CODEC2(P, D, N, X, E, O) O=(char*)D

#define	MAX_SECTOR_SIZE 0x10000

#define	SPILLFLAG_OFF 0x01 /* Never spill cache. Set via pragma */

#define	SPILLFLAG_ROLLBACK 0x02 /* Current rolling back, so do not spill */

#define	SPILLFLAG_NOSYNC 0x04 /* Spill is ok, but do not sync */

#define	PAGER_STAT_HIT 0

#define	PAGER_STAT_MISS 1

#define	PAGER_STAT_WRITE 2

#define	PAGER_INCR(v)

#define	JOURNAL_PG_SZ(pPager) ((pPager->pageSize) + 8)

#define	JOURNAL_HDR_SZ(pPager) (pPager->sectorSize)

#define	MEMDB pPager->memDb

#define	USEFETCH(x) 0

#define	PAGER_MAX_PGNO 2147483647

#define	isOpen(pFd) ((pFd)->pMethods)

#define	put32bits(A, B) sqlite3Put4byte((u8*)A,B)

#define	pager_datahash(X, Y) 0

#define	pager_pagehash(X) 0

#define	pager_set_pagehash(X)

#define	CHECK_PAGE(x)

#define	pagerReportSize(X) /* No-op if we do not support a codec */

#define	disable_simulated_io_errors()

#define	enable_simulated_io_errors()

#define	assertTruncateConstraint(pPager)

#define	DIRECT_MODE 0

#define	WALTRACE(X)

#define	WAL_MAX_VERSION 3007000

#define	WALINDEX_MAX_VERSION 3007000

#define	WAL_WRITE_LOCK 0

#define	WAL_ALL_BUT_WRITE 1

#define	WAL_CKPT_LOCK 1

#define	WAL_RECOVER_LOCK 2

#define	WAL_READ_LOCK(I) (3+(I))

#define	WAL_NREADER (SQLITE_SHM_NLOCK-3)

#define	READMARK_NOT_USED 0xffffffff

#define	WALINDEX_LOCK_OFFSET (sizeof(WalIndexHdr)*2 + sizeof(WalCkptInfo))

#define	WALINDEX_LOCK_RESERVED 16

#define	WALINDEX_HDR_SIZE (WALINDEX_LOCK_OFFSET+WALINDEX_LOCK_RESERVED)

#define	WAL_FRAME_HDRSIZE 24

#define	WAL_HDRSIZE 32

#define	WAL_MAGIC 0x377f0682

#define	walFrameOffset(iFrame, szPage)

#define	WAL_NORMAL_MODE 0

#define	WAL_EXCLUSIVE_MODE 1

#define	WAL_HEAPMEMORY_MODE 2

#define	WAL_RDWR 0 /* Normal read/write connection */

#define	WAL_RDONLY 1 /* The WAL file is readonly */

#define	WAL_SHM_RDONLY 2 /* The SHM file is readonly */

#define	HASHTABLE_NPAGE 4096 /* Must be power of 2 */

#define	HASHTABLE_HASH_1 383 /* Should be prime */

#define	HASHTABLE_NSLOT (HASHTABLE_NPAGE2) / Must be a power of 2 */

#define	HASHTABLE_NPAGE_ONE (HASHTABLE_NPAGE - (WALINDEX_HDR_SIZE/sizeof(u32)))

#define	WALINDEX_PGSZ

#define	BYTESWAP32(x)

#define	WAL_RETRY (-1)

#define	MX_CELL_SIZE(pBt) ((int)(pBt->pageSize-8))

#define	MX_CELL(pBt) ((pBt->pageSize-8)/6)

#define	SQLITE_FILE_HEADER "SQLite format 3"

#define	PTF_INTKEY 0x01

#define	PTF_ZERODATA 0x02

#define	PTF_LEAFDATA 0x04

#define	PTF_LEAF 0x08

#define	EXTRA_SIZE sizeof(MemPage)

#define	READ_LOCK 1

#define	WRITE_LOCK 2

#define	TRANS_NONE 0

#define	TRANS_READ 1

#define	TRANS_WRITE 2

#define	BTS_READ_ONLY 0x0001 /* Underlying file is readonly */

#define	BTS_PAGESIZE_FIXED 0x0002 /* Page size can no longer be changed */

#define	BTS_SECURE_DELETE 0x0004 /* PRAGMA secure_delete is enabled */

#define	BTS_INITIALLY_EMPTY 0x0008 /* Database was empty at trans start */

#define	BTS_NO_WAL 0x0010 /* Do not open write-ahead-log files */

#define	BTS_EXCLUSIVE 0x0020 /* pWriter has an exclusive lock */

#define	BTS_PENDING 0x0040 /* Waiting for read-locks to clear */

#define	BTCURSOR_MAX_DEPTH 20

#define	BTCF_WriteFlag 0x01 /* True if a write cursor */

#define	BTCF_ValidNKey 0x02 /* True if info.nKey is valid */

#define	BTCF_ValidOvfl 0x04 /* True if aOverflow is valid */

#define	BTCF_AtLast 0x08 /* Cursor is pointing ot the last entry */

#define	BTCF_Incrblob 0x10 /* True if an incremental I/O handle */

#define	CURSOR_INVALID 0

#define	CURSOR_VALID 1

#define	CURSOR_SKIPNEXT 2

#define	CURSOR_REQUIRESEEK 3

#define	CURSOR_FAULT 4

#define	PENDING_BYTE_PAGE(pBt) PAGER_MJ_PGNO(pBt)

#define	PTRMAP_PAGENO(pBt, pgno) ptrmapPageno(pBt, pgno)

#define	PTRMAP_PTROFFSET(pgptrmap, pgno) (5*(pgno-pgptrmap-1))

#define	PTRMAP_ISPAGE(pBt, pgno) (PTRMAP_PAGENO((pBt),(pgno))==(pgno))

#define	PTRMAP_ROOTPAGE 1

#define	PTRMAP_FREEPAGE 2

#define	PTRMAP_OVERFLOW1 3

#define	PTRMAP_OVERFLOW2 4

#define	PTRMAP_BTREE 5

#define	btreeIntegrity(p)

#define	ISAUTOVACUUM (pBt->autoVacuum)

#define	get2byte(x) ((x)[0]<<8 \| (x)[1])

#define	put2byte(p, v) ((p)[0] = (u8)((v)>>8), (p)[1] = (u8)(v))

#define	get4byte sqlite3Get4byte

#define	put4byte sqlite3Put4byte

#define	TRACE(X)

#define	get2byteNotZero(X) (((((int)get2byte(X))-1)&0xffff)+1)

#define	BTALLOC_ANY 0 /* Allocate any page */

#define	BTALLOC_EXACT 1 /* Allocate exact page if possible */

#define	BTALLOC_LE 2 /* Allocate any page <= the parameter */

#define	IfNotOmitAV(expr) (expr)

#define	invalidateOverflowCache(pCur) (pCur->curFlags &= ~BTCF_ValidOvfl)

#define	restoreCursorPosition(p)

#define	findCell(P, I) ((P)->aData + ((P)->maskPage & get2byte(&(P)->aCellIdx[2*(I)])))

#define	findCellv2(D, M, O, I) (D+(M&get2byte(D+(O+2*(I)))))

#define	assertCellInfo(x)

#define	getCellInfo(pCur)

#define	assertParentIndex(x, y, z)

#define	NN 1 /* Number of neighbors on either side of pPage */

#define	NB (NN2+1) / Total pages involved in the balance */

#define	MEMCELLSIZE offsetof(Mem,zMalloc)

#define	valueFromFunction(a, b, c, d, e, f) SQLITE_OK

#define	checkActiveVdbeCnt(x)

#define	vdbeInvokeSqllog(x)

#define	MAX_6BYTE ((((i64)0x00008000)<<32)-1)

#define	swapMixedEndianFloat(X)

#define	ONE_BYTE_INT(x) ((i8)(x)[0])

#define	TWO_BYTE_INT(x) (256*(i8)((x)[0])\|(x)[1])

#define	THREE_BYTE_INT(x) (65536*(i8)((x)[0])\|((x)[1]<<8)\|(x)[2])

#define	FOUR_BYTE_UINT(x) (((u32)(x)[0]<<24)\|((x)[1]<<16)\|((x)[2]<<8)\|(x)[3])

#define	FOUR_BYTE_INT(x) (16777216*(i8)((x)[0])\|((x)[1]<<16)\|((x)[2]<<8)\|(x)[3])

#define	vdbeAssertFieldCountWithinLimits(A, B, C)

#define	memAboutToChange(P, M)

#define	UPDATE_MAX_BLOBSIZE(P)

#define	VdbeBranchTaken(I, M)

#define	Stringify(P, enc)

#define	Deephemeralize(P)

#define	isSorter(x) ((x)->pSorter!=0)

#define	REGISTER_TRACE(R, M)

#define	MAX_ROWID (i64)( (((u64)0x7fffffff)<<32) \| (u64)0xffffffff )

#define	SQLITE_MAX_PMASZ (1<<29)

#define	SORTER_TYPE_INTEGER 0x01

#define	SORTER_TYPE_TEXT 0x02

#define	SRVAL(p) ((void)((SorterRecord)(p) + 1))

#define	SORTER_MAX_MERGE_COUNT 16

#define	vdbeSorterWorkDebug(x, y)

#define	vdbeSorterRewindDebug(y)

#define	vdbeSorterPopulateDebug(x, y)

#define	vdbeSorterBlockDebug(x, y, z)

#define	vdbeSorterExtendFile(x, y, z)

#define	INCRINIT_NORMAL 0

#define	INCRINIT_TASK 1

#define	INCRINIT_ROOT 2

#define	JOURNAL_CHUNKSIZE ((int)(1024-sizeof(FileChunk*)))

#define	IsStat4 0

#define	IsStat3 0

#define	SQLITE_STAT4_SAMPLES 1

#define	IsStat34 (IsStat3+IsStat4) /* 1 for STAT3 or STAT4. 0 otherwise */

#define	STAT_GET_STAT1 0 /* "stat" column of stat1 table */

#define	STAT_GET_ROWID 1 /* "rowid" column of stat[34] entry */

#define	STAT_GET_NEQ 2 /* "neq" column of stat[34] entry */

#define	STAT_GET_NLT 3 /* "nlt" column of stat[34] entry */

#define	STAT_GET_NDLT 4 /* "ndlt" column of stat[34] entry */

#define	SAVE_SZ (sizeof(Parse) - offsetof(Parse,nVar))

#define	STRICMP(x, y)

#define	FUNC_PERFECT_MATCH 6 /* The score for a perfect match */

#define	noopFunc versionFunc /* Substitute function - never called */

#define	GlobUpperToLower(A) if( A<=0x7f ){ A = sqlite3UpperToLower[A]; }

#define	GlobUpperToLowerAscii(A) A = sqlite3UpperToLower[A]

#define	COLUMN_MASK(x) (((x)>31) ? 0xffffffff : ((u32)1<<(x)))

#define	_SQLITE3EXT_H_

#define	SQLITE_EXTENSION_INIT1 /no-op/

#define	SQLITE_EXTENSION_INIT2(v) (void)v; /* unused parameter */

#define	SQLITE_EXTENSION_INIT3 /no-op/

#define	sqlite3_column_database_name 0

#define	sqlite3_column_database_name16 0

#define	sqlite3_column_table_name 0

#define	sqlite3_column_table_name16 0

#define	sqlite3_column_origin_name 0

#define	sqlite3_column_origin_name16 0

#define	wsdAutoextInit

#define	wsdAutoext sqlite3Autoext

#define	PragTyp_HEADER_VALUE 0

#define	PragTyp_AUTO_VACUUM 1

#define	PragTyp_FLAG 2

#define	PragTyp_BUSY_TIMEOUT 3

#define	PragTyp_CACHE_SIZE 4

#define	PragTyp_CASE_SENSITIVE_LIKE 5

#define	PragTyp_COLLATION_LIST 6

#define	PragTyp_COMPILE_OPTIONS 7

#define	PragTyp_DATA_STORE_DIRECTORY 8

#define	PragTyp_DATABASE_LIST 9

#define	PragTyp_DEFAULT_CACHE_SIZE 10

#define	PragTyp_ENCODING 11

#define	PragTyp_FOREIGN_KEY_CHECK 12

#define	PragTyp_FOREIGN_KEY_LIST 13

#define	PragTyp_INCREMENTAL_VACUUM 14

#define	PragTyp_INDEX_INFO 15

#define	PragTyp_INDEX_LIST 16

#define	PragTyp_INTEGRITY_CHECK 17

#define	PragTyp_JOURNAL_MODE 18

#define	PragTyp_JOURNAL_SIZE_LIMIT 19

#define	PragTyp_LOCK_PROXY_FILE 20

#define	PragTyp_LOCKING_MODE 21

#define	PragTyp_PAGE_COUNT 22

#define	PragTyp_MMAP_SIZE 23

#define	PragTyp_PAGE_SIZE 24

#define	PragTyp_SECURE_DELETE 25

#define	PragTyp_SHRINK_MEMORY 26

#define	PragTyp_SOFT_HEAP_LIMIT 27

#define	PragTyp_STATS 28

#define	PragTyp_SYNCHRONOUS 29

#define	PragTyp_TABLE_INFO 30

#define	PragTyp_TEMP_STORE 31

#define	PragTyp_TEMP_STORE_DIRECTORY 32

#define	PragTyp_THREADS 33

#define	PragTyp_WAL_AUTOCHECKPOINT 34

#define	PragTyp_WAL_CHECKPOINT 35

#define	PragTyp_ACTIVATE_EXTENSIONS 36

#define	PragTyp_HEXKEY 37

#define	PragTyp_KEY 38

#define	PragTyp_REKEY 39

#define	PragTyp_LOCK_STATUS 40

#define	PragTyp_PARSER_TRACE 41

#define	PragFlag_NeedSchema 0x01

#define	PragFlag_ReadOnly 0x02

#define	SQLITE_INTEGRITY_CHECK_ERROR_MAX 100

#define	SELECTTRACE(K, P, S, X)

#define	SORTFLAG_UseSorter 0x01 /* Use SorterOpen instead of OpenEphemeral */

#define	explainSetInteger(a, b) a = b

#define	columnType(A, B, C, D, E, F) columnTypeImpl(A,B,F)

#define	WHERETRACE(K, X)

#define	WHERE_LOOP_XFER_SZ offsetof(WhereLoop,nLSlot)

#define	N_OR_COST 3

#define	TERM_DYNAMIC 0x01 /* Need to call sqlite3ExprDelete(db, pExpr) */

#define	TERM_VIRTUAL 0x02 /* Added by the optimizer. Do not code */

#define	TERM_CODED 0x04 /* This term is already coded */

#define	TERM_COPIED 0x08 /* Has a child */

#define	TERM_ORINFO 0x10 /* Need to free the WhereTerm.u.pOrInfo object */

#define	TERM_ANDINFO 0x20 /* Need to free the WhereTerm.u.pAndInfo obj */

#define	TERM_OR_OK 0x40 /* Used during OR-clause processing */

#define	TERM_VNULL 0x00 /* Disabled if not using stat3 */

#define	TERM_LIKEOPT 0x100 /* Virtual terms from the LIKE optimization */

#define	TERM_LIKECOND 0x200 /* Conditionally this LIKE operator term */

#define	TERM_LIKE 0x400 /* The original LIKE operator */

#define	WO_IN 0x001

#define	WO_EQ 0x002

#define	WO_LT (WO_EQ<<(TK_LT-TK_EQ))

#define	WO_LE (WO_EQ<<(TK_LE-TK_EQ))

#define	WO_GT (WO_EQ<<(TK_GT-TK_EQ))

#define	WO_GE (WO_EQ<<(TK_GE-TK_EQ))

#define	WO_MATCH 0x040

#define	WO_ISNULL 0x080

#define	WO_OR 0x100 /* Two or more OR-connected terms */

#define	WO_AND 0x200 /* Two or more AND-connected terms */

#define	WO_EQUIV 0x400 /* Of the form A==B, both columns */

#define	WO_NOOP 0x800 /* This term does not restrict search space */

#define	WO_ALL 0xfff /* Mask of all possible WO_* values */

#define	WO_SINGLE 0x0ff /* Mask of all non-compound WO_* values */

#define	WHERE_COLUMN_EQ 0x00000001 /* x=EXPR */

#define	WHERE_COLUMN_RANGE 0x00000002 /* x<EXPR and/or x>EXPR */

#define	WHERE_COLUMN_IN 0x00000004 /* x IN (...) */

#define	WHERE_COLUMN_NULL 0x00000008 /* x IS NULL */

#define	WHERE_CONSTRAINT 0x0000000f /* Any of the WHERE_COLUMN_xxx values */

#define	WHERE_TOP_LIMIT 0x00000010 /* x<EXPR or x<=EXPR constraint */

#define	WHERE_BTM_LIMIT 0x00000020 /* x>EXPR or x>=EXPR constraint */

#define	WHERE_BOTH_LIMIT 0x00000030 /* Both x>EXPR and x<EXPR */

#define	WHERE_IDX_ONLY 0x00000040 /* Use index only - omit table */

#define	WHERE_IPK 0x00000100 /* x is the INTEGER PRIMARY KEY */

#define	WHERE_INDEXED 0x00000200 /* WhereLoop.u.btree.pIndex is valid */

#define	WHERE_VIRTUALTABLE 0x00000400 /* WhereLoop.u.vtab is valid */

#define	WHERE_IN_ABLE 0x00000800 /* Able to support an IN operator */

#define	WHERE_ONEROW 0x00001000 /* Selects no more than one row */

#define	WHERE_MULTI_OR 0x00002000 /* OR using multiple indices */

#define	WHERE_AUTO_INDEX 0x00004000 /* Uses an ephemeral index */

#define	WHERE_SKIPSCAN 0x00008000 /* Uses the skip-scan algorithm */

#define	WHERE_UNQ_WANTED 0x00010000 /* WHERE_ONEROW would have been helpful*/

#define	WHERE_PARTIALIDX 0x00020000 /* The automatic index is partial */

#define	initMaskSet(P) (P)->n=0

#define	TRACE_IDX_INPUTS(A)

#define	TRACE_IDX_OUTPUTS(A)

#define	addScanStatus(a, b, c, d) ((void)d)

#define	ApplyCostMultiplier(C, T)

#define	YYNOERRORRECOVERY 1

#define	yytestcase(X) testcase(X)

#define	INTERFACE 1

#define	YYCODETYPE unsigned char

#define	YYNOCODE 254

#define	YYACTIONTYPE unsigned short int

#define	YYWILDCARD 70

#define	sqlite3ParserTOKENTYPE Token

#define	YYSTACKDEPTH 100

#define	sqlite3ParserARG_SDECL Parse *pParse;

#define	sqlite3ParserARG_PDECL ,Parse *pParse

#define	sqlite3ParserARG_FETCH Parse *pParse = yypParser->pParse

#define	sqlite3ParserARG_STORE yypParser->pParse = pParse

#define	YYNSTATE 642

#define	YYNRULE 327

#define	YYFALLBACK 1

#define	YY_NO_ACTION (YYNSTATE+YYNRULE+2)

#define	YY_ACCEPT_ACTION (YYNSTATE+YYNRULE+1)

#define	YY_ERROR_ACTION (YYNSTATE+YYNRULE)

#define	YY_ACTTAB_COUNT (1497)

#define	YY_SHIFT_USE_DFLT (-86)

#define	YY_SHIFT_COUNT (429)

#define	YY_SHIFT_MIN (-85)

#define	YY_SHIFT_MAX (1383)

#define	YY_REDUCE_USE_DFLT (-110)

#define	YY_REDUCE_COUNT (305)

#define	YY_REDUCE_MIN (-109)

#define	YY_REDUCE_MAX (1323)

#define	TOKEN (yyminor.yy0)

#define	charMap(X) sqlite3UpperToLower[(unsigned char)X]

#define	SQLITE_N_KEYWORD 124

#define	IdChar(C) ((sqlite3CtypeMap[(unsigned char)C]&0x46)!=0)

#define	tkSEMI 0

#define	tkWS 1

#define	tkOTHER 2

#define	tkEXPLAIN 3

#define	tkCREATE 4

#define	tkTEMP 5

#define	tkTRIGGER 6

#define	tkEND 7

#define	_FTSINT_H

Typedefs
typedef long long int	sqlite_int64

typedef unsigned long long int	sqlite_uint64

typedef sqlite_int64	sqlite3_int64

typedef sqlite_uint64	sqlite3_uint64

typedef int(*	sqlite3_callback) (void , int, char , char *)

typedef void(*	sqlite3_syscall_ptr) (void)

typedef struct sqlite3_stmt	sqlite3_stmt

typedef void(*	sqlite3_destructor_type) (void *)

typedef struct sqlite3_blob	sqlite3_blob

typedef struct sqlite3_pcache	sqlite3_pcache

typedef double	sqlite3_rtree_dbl

typedef sqlite_int64	i64

typedef sqlite_uint64	u64

typedef UINT32_TYPE	u32

typedef UINT16_TYPE	u16

typedef INT16_TYPE	i16

typedef UINT8_TYPE	u8

typedef INT8_TYPE	i8

typedef u32	tRowcnt

typedef INT16_TYPE	LogEst

typedef struct KeyClass	KeyClass

typedef struct TreeView	TreeView

typedef int(*	RecordCompare) (int, const void , UnpackedRecord )

typedef u32	Pgno

typedef int(*	sqlite3_xauth) (void , int, const char , const char , const char , const char *)

typedef i16	ynVar

typedef u64	Bitmask

typedef unsigned int	yDbMask

typedef unsigned	Bool

typedef unsigned	bft

typedef unsigned char	etByte

typedef u16	ht_slot

typedef int(*	SorterCompare) (SortSubtask , int , const void , int, const void , int)

Functions
SQLITE_API const char *SQLITE_STDCALL	sqlite3_libversion (void)

SQLITE_API const char *SQLITE_STDCALL	sqlite3_sourceid (void)

SQLITE_API int SQLITE_STDCALL	sqlite3_libversion_number (void)

SQLITE_API int SQLITE_STDCALL	sqlite3_compileoption_used (const char *zOptName)

SQLITE_API const char *SQLITE_STDCALL	sqlite3_compileoption_get (int N)

SQLITE_API int SQLITE_STDCALL	sqlite3_threadsafe (void)

SQLITE_API int SQLITE_STDCALL	sqlite3_close (sqlite3 *)

SQLITE_API int SQLITE_STDCALL	sqlite3_close_v2 (sqlite3 *)

SQLITE_API int SQLITE_STDCALL	sqlite3_exec (sqlite3 , const char sql, int(callback)(void , int, char , char ), void , char *errmsg)

SQLITE_API int SQLITE_STDCALL	sqlite3_initialize (void)

SQLITE_API int SQLITE_STDCALL	sqlite3_shutdown (void)

SQLITE_API int SQLITE_STDCALL	sqlite3_os_init (void)

SQLITE_API int SQLITE_STDCALL	sqlite3_os_end (void)

SQLITE_API int SQLITE_CDECL	sqlite3_config (int,...)

SQLITE_API int SQLITE_CDECL	sqlite3_db_config (sqlite3 *, int op,...)

SQLITE_API int SQLITE_STDCALL	sqlite3_extended_result_codes (sqlite3 *, int onoff)

SQLITE_API sqlite3_int64 SQLITE_STDCALL	sqlite3_last_insert_rowid (sqlite3 *)

SQLITE_API int SQLITE_STDCALL	sqlite3_changes (sqlite3 *)

SQLITE_API int SQLITE_STDCALL	sqlite3_total_changes (sqlite3 *)

SQLITE_API void SQLITE_STDCALL	sqlite3_interrupt (sqlite3 *)

SQLITE_API int SQLITE_STDCALL	sqlite3_complete (const char *sql)

SQLITE_API int SQLITE_STDCALL	sqlite3_complete16 (const void *sql)

SQLITE_API int SQLITE_STDCALL	sqlite3_busy_handler (sqlite3 , int()(void , int), void )

SQLITE_API int SQLITE_STDCALL	sqlite3_busy_timeout (sqlite3 *, int ms)

SQLITE_API int SQLITE_STDCALL	sqlite3_get_table (sqlite3 db, const char zSql, char **pazResult, int pnRow, int pnColumn, char *pzErrmsg)

SQLITE_API void SQLITE_STDCALL	sqlite3_free_table (char **result)

SQLITE_API char *SQLITE_CDECL	sqlite3_mprintf (const char *,...)

SQLITE_API char *SQLITE_STDCALL	sqlite3_vmprintf (const char *, va_list)

SQLITE_API char *SQLITE_CDECL	sqlite3_snprintf (int, char , const char ,...)

SQLITE_API char *SQLITE_STDCALL	sqlite3_vsnprintf (int, char , const char , va_list)

SQLITE_API void *SQLITE_STDCALL	sqlite3_malloc (int)

SQLITE_API void *SQLITE_STDCALL	sqlite3_malloc64 (sqlite3_uint64)

SQLITE_API void *SQLITE_STDCALL	sqlite3_realloc (void *, int)

SQLITE_API void *SQLITE_STDCALL	sqlite3_realloc64 (void *, sqlite3_uint64)

SQLITE_API void SQLITE_STDCALL	sqlite3_free (void *)

SQLITE_API sqlite3_uint64 SQLITE_STDCALL	sqlite3_msize (void *)

SQLITE_API sqlite3_int64 SQLITE_STDCALL	sqlite3_memory_used (void)

SQLITE_API sqlite3_int64 SQLITE_STDCALL	sqlite3_memory_highwater (int resetFlag)

SQLITE_API void SQLITE_STDCALL	sqlite3_randomness (int N, void *P)

SQLITE_API int SQLITE_STDCALL	sqlite3_set_authorizer (sqlite3 , int(xAuth)(void , int, const char , const char , const char , const char ), void pUserData)

SQLITE_API void *SQLITE_STDCALL	sqlite3_trace (sqlite3 , void(xTrace)(void , const char ), void *)

SQLITE_API SQLITE_EXPERIMENTAL void *SQLITE_STDCALL	sqlite3_profile (sqlite3 , void(xProfile)(void , const char , sqlite3_uint64), void *)

SQLITE_API void SQLITE_STDCALL	sqlite3_progress_handler (sqlite3 , int, int()(void ), void )

SQLITE_API int SQLITE_STDCALL	sqlite3_open (const char filename, sqlite3 *ppDb)

SQLITE_API int SQLITE_STDCALL	sqlite3_open16 (const void filename, sqlite3 *ppDb)

SQLITE_API int SQLITE_STDCALL	sqlite3_open_v2 (const char filename, sqlite3 ppDb, int flags, const char zVfs)

SQLITE_API const char *SQLITE_STDCALL	sqlite3_uri_parameter (const char zFilename, const char zParam)

SQLITE_API int SQLITE_STDCALL	sqlite3_uri_boolean (const char zFile, const char zParam, int bDefault)

SQLITE_API sqlite3_int64 SQLITE_STDCALL	sqlite3_uri_int64 (const char , const char , sqlite3_int64)

SQLITE_API int SQLITE_STDCALL	sqlite3_errcode (sqlite3 *db)

SQLITE_API int SQLITE_STDCALL	sqlite3_extended_errcode (sqlite3 *db)

SQLITE_API const char *SQLITE_STDCALL	sqlite3_errmsg (sqlite3 *)

SQLITE_API const void *SQLITE_STDCALL	sqlite3_errmsg16 (sqlite3 *)

SQLITE_API const char *SQLITE_STDCALL	sqlite3_errstr (int)

SQLITE_API int SQLITE_STDCALL	sqlite3_limit (sqlite3 *, int id, int newVal)

SQLITE_API int SQLITE_STDCALL	sqlite3_prepare (sqlite3 db, const char zSql, int nByte, sqlite3_stmt ppStmt, const char pzTail)

SQLITE_API int SQLITE_STDCALL	sqlite3_prepare_v2 (sqlite3 db, const char zSql, int nByte, sqlite3_stmt ppStmt, const char pzTail)

SQLITE_API int SQLITE_STDCALL	sqlite3_prepare16 (sqlite3 db, const void zSql, int nByte, sqlite3_stmt ppStmt, const void pzTail)

SQLITE_API int SQLITE_STDCALL	sqlite3_prepare16_v2 (sqlite3 db, const void zSql, int nByte, sqlite3_stmt ppStmt, const void pzTail)

SQLITE_API const char *SQLITE_STDCALL	sqlite3_sql (sqlite3_stmt *pStmt)

SQLITE_API int SQLITE_STDCALL	sqlite3_stmt_readonly (sqlite3_stmt *pStmt)

SQLITE_API int SQLITE_STDCALL	sqlite3_stmt_busy (sqlite3_stmt *)

SQLITE_API int SQLITE_STDCALL	sqlite3_bind_blob (sqlite3_stmt , int, const void , int n, void()(void ))

SQLITE_API int SQLITE_STDCALL	sqlite3_bind_blob64 (sqlite3_stmt , int, const void , sqlite3_uint64, void()(void ))

SQLITE_API int SQLITE_STDCALL	sqlite3_bind_double (sqlite3_stmt *, int, double)

SQLITE_API int SQLITE_STDCALL	sqlite3_bind_int (sqlite3_stmt *, int, int)

SQLITE_API int SQLITE_STDCALL	sqlite3_bind_int64 (sqlite3_stmt *, int, sqlite3_int64)

SQLITE_API int SQLITE_STDCALL	sqlite3_bind_null (sqlite3_stmt *, int)

SQLITE_API int SQLITE_STDCALL	sqlite3_bind_text (sqlite3_stmt , int, const char , int, void()(void ))

SQLITE_API int SQLITE_STDCALL	sqlite3_bind_text16 (sqlite3_stmt , int, const void , int, void()(void ))

SQLITE_API int SQLITE_STDCALL	sqlite3_bind_text64 (sqlite3_stmt , int, const char , sqlite3_uint64, void()(void ), unsigned char encoding)

SQLITE_API int SQLITE_STDCALL	sqlite3_bind_value (sqlite3_stmt , int, const sqlite3_value )

SQLITE_API int SQLITE_STDCALL	sqlite3_bind_zeroblob (sqlite3_stmt *, int, int n)

SQLITE_API int SQLITE_STDCALL	sqlite3_bind_parameter_count (sqlite3_stmt *)

SQLITE_API const char *SQLITE_STDCALL	sqlite3_bind_parameter_name (sqlite3_stmt *, int)

SQLITE_API int SQLITE_STDCALL	sqlite3_bind_parameter_index (sqlite3_stmt , const char zName)

SQLITE_API int SQLITE_STDCALL	sqlite3_clear_bindings (sqlite3_stmt *)

SQLITE_API int SQLITE_STDCALL	sqlite3_column_count (sqlite3_stmt *pStmt)

SQLITE_API const char *SQLITE_STDCALL	sqlite3_column_name (sqlite3_stmt *, int N)

SQLITE_API const void *SQLITE_STDCALL	sqlite3_column_name16 (sqlite3_stmt *, int N)

SQLITE_API const char *SQLITE_STDCALL	sqlite3_column_database_name (sqlite3_stmt *, int)

SQLITE_API const void *SQLITE_STDCALL	sqlite3_column_database_name16 (sqlite3_stmt *, int)

SQLITE_API const char *SQLITE_STDCALL	sqlite3_column_table_name (sqlite3_stmt *, int)

SQLITE_API const void *SQLITE_STDCALL	sqlite3_column_table_name16 (sqlite3_stmt *, int)

SQLITE_API const char *SQLITE_STDCALL	sqlite3_column_origin_name (sqlite3_stmt *, int)

SQLITE_API const void *SQLITE_STDCALL	sqlite3_column_origin_name16 (sqlite3_stmt *, int)

SQLITE_API const char *SQLITE_STDCALL	sqlite3_column_decltype (sqlite3_stmt *, int)

SQLITE_API const void *SQLITE_STDCALL	sqlite3_column_decltype16 (sqlite3_stmt *, int)

SQLITE_API int SQLITE_STDCALL	sqlite3_step (sqlite3_stmt *)

SQLITE_API int SQLITE_STDCALL	sqlite3_data_count (sqlite3_stmt *pStmt)

SQLITE_API const void *SQLITE_STDCALL	sqlite3_column_blob (sqlite3_stmt *, int iCol)

SQLITE_API int SQLITE_STDCALL	sqlite3_column_bytes (sqlite3_stmt *, int iCol)

SQLITE_API int SQLITE_STDCALL	sqlite3_column_bytes16 (sqlite3_stmt *, int iCol)

SQLITE_API double SQLITE_STDCALL	sqlite3_column_double (sqlite3_stmt *, int iCol)

SQLITE_API int SQLITE_STDCALL	sqlite3_column_int (sqlite3_stmt *, int iCol)

SQLITE_API sqlite3_int64 SQLITE_STDCALL	sqlite3_column_int64 (sqlite3_stmt *, int iCol)

SQLITE_API const unsigned char *SQLITE_STDCALL	sqlite3_column_text (sqlite3_stmt *, int iCol)

SQLITE_API const void *SQLITE_STDCALL	sqlite3_column_text16 (sqlite3_stmt *, int iCol)

SQLITE_API int SQLITE_STDCALL	sqlite3_column_type (sqlite3_stmt *, int iCol)

SQLITE_API sqlite3_value *SQLITE_STDCALL	sqlite3_column_value (sqlite3_stmt *, int iCol)

SQLITE_API int SQLITE_STDCALL	sqlite3_finalize (sqlite3_stmt *pStmt)

SQLITE_API int SQLITE_STDCALL	sqlite3_reset (sqlite3_stmt *pStmt)

SQLITE_API int SQLITE_STDCALL	sqlite3_create_function (sqlite3 db, const char zFunctionName, int nArg, int eTextRep, void pApp, void(xFunc)(sqlite3_context , int, sqlite3_value ), void(xStep)(sqlite3_context , int, sqlite3_value ), void(xFinal)(sqlite3_context *))

SQLITE_API int SQLITE_STDCALL	sqlite3_create_function16 (sqlite3 db, const void zFunctionName, int nArg, int eTextRep, void pApp, void(xFunc)(sqlite3_context , int, sqlite3_value ), void(xStep)(sqlite3_context , int, sqlite3_value ), void(xFinal)(sqlite3_context *))

SQLITE_API int SQLITE_STDCALL	sqlite3_create_function_v2 (sqlite3 db, const char zFunctionName, int nArg, int eTextRep, void pApp, void(xFunc)(sqlite3_context , int, sqlite3_value ), void(xStep)(sqlite3_context , int, sqlite3_value ), void(xFinal)(sqlite3_context ), void(xDestroy)(void *))

SQLITE_API SQLITE_DEPRECATED int SQLITE_STDCALL	sqlite3_aggregate_count (sqlite3_context *)

SQLITE_API SQLITE_DEPRECATED int SQLITE_STDCALL	sqlite3_expired (sqlite3_stmt *)

SQLITE_API SQLITE_DEPRECATED int SQLITE_STDCALL	sqlite3_transfer_bindings (sqlite3_stmt , sqlite3_stmt )

SQLITE_API SQLITE_DEPRECATED int SQLITE_STDCALL	sqlite3_global_recover (void)

SQLITE_API SQLITE_DEPRECATED void SQLITE_STDCALL	sqlite3_thread_cleanup (void)

SQLITE_API SQLITE_DEPRECATED int SQLITE_STDCALL	sqlite3_memory_alarm (void()(void , sqlite3_int64, int), void *, sqlite3_int64)

SQLITE_API const void *SQLITE_STDCALL	sqlite3_value_blob (sqlite3_value *)

SQLITE_API int SQLITE_STDCALL	sqlite3_value_bytes (sqlite3_value *)

SQLITE_API int SQLITE_STDCALL	sqlite3_value_bytes16 (sqlite3_value *)

SQLITE_API double SQLITE_STDCALL	sqlite3_value_double (sqlite3_value *)

SQLITE_API int SQLITE_STDCALL	sqlite3_value_int (sqlite3_value *)

SQLITE_API sqlite3_int64 SQLITE_STDCALL	sqlite3_value_int64 (sqlite3_value *)

SQLITE_API const unsigned char *SQLITE_STDCALL	sqlite3_value_text (sqlite3_value *)

SQLITE_API const void *SQLITE_STDCALL	sqlite3_value_text16 (sqlite3_value *)

SQLITE_API const void *SQLITE_STDCALL	sqlite3_value_text16le (sqlite3_value *)

SQLITE_API const void *SQLITE_STDCALL	sqlite3_value_text16be (sqlite3_value *)

SQLITE_API int SQLITE_STDCALL	sqlite3_value_type (sqlite3_value *)

SQLITE_API int SQLITE_STDCALL	sqlite3_value_numeric_type (sqlite3_value *)

SQLITE_API void *SQLITE_STDCALL	sqlite3_aggregate_context (sqlite3_context *, int nBytes)

SQLITE_API void *SQLITE_STDCALL	sqlite3_user_data (sqlite3_context *)

SQLITE_API sqlite3 *SQLITE_STDCALL	sqlite3_context_db_handle (sqlite3_context *)

SQLITE_API void *SQLITE_STDCALL	sqlite3_get_auxdata (sqlite3_context *, int N)

SQLITE_API void SQLITE_STDCALL	sqlite3_set_auxdata (sqlite3_context , int N, void , void()(void ))

SQLITE_API void SQLITE_STDCALL	sqlite3_result_blob (sqlite3_context , const void , int, void()(void ))

SQLITE_API void SQLITE_STDCALL	sqlite3_result_blob64 (sqlite3_context , const void , sqlite3_uint64, void()(void ))

SQLITE_API void SQLITE_STDCALL	sqlite3_result_double (sqlite3_context *, double)

SQLITE_API void SQLITE_STDCALL	sqlite3_result_error (sqlite3_context , const char , int)

SQLITE_API void SQLITE_STDCALL	sqlite3_result_error16 (sqlite3_context , const void , int)

SQLITE_API void SQLITE_STDCALL	sqlite3_result_error_toobig (sqlite3_context *)

SQLITE_API void SQLITE_STDCALL	sqlite3_result_error_nomem (sqlite3_context *)

SQLITE_API void SQLITE_STDCALL	sqlite3_result_error_code (sqlite3_context *, int)

SQLITE_API void SQLITE_STDCALL	sqlite3_result_int (sqlite3_context *, int)

SQLITE_API void SQLITE_STDCALL	sqlite3_result_int64 (sqlite3_context *, sqlite3_int64)

SQLITE_API void SQLITE_STDCALL	sqlite3_result_null (sqlite3_context *)

SQLITE_API void SQLITE_STDCALL	sqlite3_result_text (sqlite3_context , const char , int, void()(void ))

SQLITE_API void SQLITE_STDCALL	sqlite3_result_text64 (sqlite3_context , const char , sqlite3_uint64, void()(void ), unsigned char encoding)

SQLITE_API void SQLITE_STDCALL	sqlite3_result_text16 (sqlite3_context , const void , int, void()(void ))

SQLITE_API void SQLITE_STDCALL	sqlite3_result_text16le (sqlite3_context , const void , int, void()(void ))

SQLITE_API void SQLITE_STDCALL	sqlite3_result_text16be (sqlite3_context , const void , int, void()(void ))

SQLITE_API void SQLITE_STDCALL	sqlite3_result_value (sqlite3_context , sqlite3_value )

SQLITE_API void SQLITE_STDCALL	sqlite3_result_zeroblob (sqlite3_context *, int n)

SQLITE_API int SQLITE_STDCALL	sqlite3_create_collation (sqlite3 , const char zName, int eTextRep, void pArg, int(xCompare)(void , int, const void , int, const void *))

SQLITE_API int SQLITE_STDCALL	sqlite3_create_collation_v2 (sqlite3 , const char zName, int eTextRep, void pArg, int(xCompare)(void , int, const void , int, const void ), void(xDestroy)(void *))

SQLITE_API int SQLITE_STDCALL	sqlite3_create_collation16 (sqlite3 , const void zName, int eTextRep, void pArg, int(xCompare)(void , int, const void , int, const void *))

SQLITE_API int SQLITE_STDCALL	sqlite3_collation_needed (sqlite3 , void , void()(void , sqlite3 , int eTextRep, const char ))

SQLITE_API int SQLITE_STDCALL	sqlite3_collation_needed16 (sqlite3 , void , void()(void , sqlite3 , int eTextRep, const void ))

SQLITE_API int SQLITE_STDCALL	sqlite3_sleep (int)

SQLITE_API int SQLITE_STDCALL	sqlite3_get_autocommit (sqlite3 *)

SQLITE_API sqlite3 *SQLITE_STDCALL	sqlite3_db_handle (sqlite3_stmt *)

SQLITE_API const char *SQLITE_STDCALL	sqlite3_db_filename (sqlite3 db, const char zDbName)

SQLITE_API int SQLITE_STDCALL	sqlite3_db_readonly (sqlite3 db, const char zDbName)

SQLITE_API sqlite3_stmt *SQLITE_STDCALL	sqlite3_next_stmt (sqlite3 pDb, sqlite3_stmt pStmt)

SQLITE_API void *SQLITE_STDCALL	sqlite3_commit_hook (sqlite3 , int()(void ), void )

SQLITE_API void *SQLITE_STDCALL	sqlite3_rollback_hook (sqlite3 , void()(void ), void )

SQLITE_API void *SQLITE_STDCALL	sqlite3_update_hook (sqlite3 , void()(void , int, char const , char const , sqlite3_int64), void )

SQLITE_API int SQLITE_STDCALL	sqlite3_enable_shared_cache (int)

SQLITE_API int SQLITE_STDCALL	sqlite3_release_memory (int)

SQLITE_API int SQLITE_STDCALL	sqlite3_db_release_memory (sqlite3 *)

SQLITE_API sqlite3_int64 SQLITE_STDCALL	sqlite3_soft_heap_limit64 (sqlite3_int64 N)

SQLITE_API SQLITE_DEPRECATED void SQLITE_STDCALL	sqlite3_soft_heap_limit (int N)

SQLITE_API int SQLITE_STDCALL	sqlite3_table_column_metadata (sqlite3 db, const char zDbName, const char zTableName, const char zColumnName, char const pzDataType, char const pzCollSeq, int pNotNull, int pPrimaryKey, int *pAutoinc)

SQLITE_API int SQLITE_STDCALL	sqlite3_load_extension (sqlite3 db, const char zFile, const char zProc, char *pzErrMsg)

SQLITE_API int SQLITE_STDCALL	sqlite3_enable_load_extension (sqlite3 *db, int onoff)

SQLITE_API int SQLITE_STDCALL	sqlite3_auto_extension (void(*xEntryPoint)(void))

SQLITE_API int SQLITE_STDCALL	sqlite3_cancel_auto_extension (void(*xEntryPoint)(void))

SQLITE_API void SQLITE_STDCALL	sqlite3_reset_auto_extension (void)

SQLITE_API int SQLITE_STDCALL	sqlite3_create_module (sqlite3 db, const char zName, const sqlite3_module p, void pClientData)

SQLITE_API int SQLITE_STDCALL	sqlite3_create_module_v2 (sqlite3 db, const char zName, const sqlite3_module p, void pClientData, void(xDestroy)(void ))

SQLITE_API int SQLITE_STDCALL	sqlite3_declare_vtab (sqlite3 , const char zSQL)

SQLITE_API int SQLITE_STDCALL	sqlite3_overload_function (sqlite3 , const char zFuncName, int nArg)

SQLITE_API int SQLITE_STDCALL	sqlite3_blob_open (sqlite3 , const char zDb, const char zTable, const char zColumn, sqlite3_int64 iRow, int flags, sqlite3_blob **ppBlob)

SQLITE_API SQLITE_EXPERIMENTAL int SQLITE_STDCALL	sqlite3_blob_reopen (sqlite3_blob *, sqlite3_int64)

SQLITE_API int SQLITE_STDCALL	sqlite3_blob_close (sqlite3_blob *)

SQLITE_API int SQLITE_STDCALL	sqlite3_blob_bytes (sqlite3_blob *)

SQLITE_API int SQLITE_STDCALL	sqlite3_blob_read (sqlite3_blob , void Z, int N, int iOffset)

SQLITE_API int SQLITE_STDCALL	sqlite3_blob_write (sqlite3_blob , const void z, int n, int iOffset)

SQLITE_API sqlite3_vfs *SQLITE_STDCALL	sqlite3_vfs_find (const char *zVfsName)

SQLITE_API int SQLITE_STDCALL	sqlite3_vfs_register (sqlite3_vfs *, int makeDflt)

SQLITE_API int SQLITE_STDCALL	sqlite3_vfs_unregister (sqlite3_vfs *)

SQLITE_API sqlite3_mutex *SQLITE_STDCALL	sqlite3_mutex_alloc (int)

SQLITE_API void SQLITE_STDCALL	sqlite3_mutex_free (sqlite3_mutex *)

SQLITE_API void SQLITE_STDCALL	sqlite3_mutex_enter (sqlite3_mutex *)

SQLITE_API int SQLITE_STDCALL	sqlite3_mutex_try (sqlite3_mutex *)

SQLITE_API void SQLITE_STDCALL	sqlite3_mutex_leave (sqlite3_mutex *)

SQLITE_API int SQLITE_STDCALL	sqlite3_mutex_held (sqlite3_mutex *)

SQLITE_API int SQLITE_STDCALL	sqlite3_mutex_notheld (sqlite3_mutex *)

SQLITE_API sqlite3_mutex *SQLITE_STDCALL	sqlite3_db_mutex (sqlite3 *)

SQLITE_API int SQLITE_STDCALL	sqlite3_file_control (sqlite3 , const char zDbName, int op, void *)

SQLITE_API int SQLITE_CDECL	sqlite3_test_control (int op,...)

SQLITE_API int SQLITE_STDCALL	sqlite3_status (int op, int pCurrent, int pHighwater, int resetFlag)

SQLITE_API int SQLITE_STDCALL	sqlite3_status64 (int op, sqlite3_int64 pCurrent, sqlite3_int64 pHighwater, int resetFlag)

SQLITE_API int SQLITE_STDCALL	sqlite3_db_status (sqlite3 , int op, int pCur, int *pHiwtr, int resetFlg)

SQLITE_API int SQLITE_STDCALL	sqlite3_stmt_status (sqlite3_stmt *, int op, int resetFlg)

SQLITE_API sqlite3_backup *SQLITE_STDCALL	sqlite3_backup_init (sqlite3 pDest, const char zDestName, sqlite3 pSource, const char zSourceName)

SQLITE_API int SQLITE_STDCALL	sqlite3_backup_step (sqlite3_backup *p, int nPage)

SQLITE_API int SQLITE_STDCALL	sqlite3_backup_finish (sqlite3_backup *p)

SQLITE_API int SQLITE_STDCALL	sqlite3_backup_remaining (sqlite3_backup *p)

SQLITE_API int SQLITE_STDCALL	sqlite3_backup_pagecount (sqlite3_backup *p)

SQLITE_API int SQLITE_STDCALL	sqlite3_unlock_notify (sqlite3 pBlocked, void(xNotify)(void *apArg, int nArg), void pNotifyArg)

SQLITE_API int SQLITE_STDCALL	sqlite3_stricmp (const char , const char )

SQLITE_API int SQLITE_STDCALL	sqlite3_strnicmp (const char , const char , int)

SQLITE_API int SQLITE_STDCALL	sqlite3_strglob (const char zGlob, const char zStr)

SQLITE_API void SQLITE_CDECL	sqlite3_log (int iErrCode, const char *zFormat,...)

SQLITE_API void *SQLITE_STDCALL	sqlite3_wal_hook (sqlite3 , int()(void , sqlite3 , const char , int), void )

SQLITE_API int SQLITE_STDCALL	sqlite3_wal_autocheckpoint (sqlite3 *db, int N)

SQLITE_API int SQLITE_STDCALL	sqlite3_wal_checkpoint (sqlite3 db, const char zDb)

SQLITE_API int SQLITE_STDCALL	sqlite3_wal_checkpoint_v2 (sqlite3 db, const char zDb, int eMode, int pnLog, int pnCkpt)

SQLITE_API int SQLITE_CDECL	sqlite3_vtab_config (sqlite3 *, int op,...)

SQLITE_API int SQLITE_STDCALL	sqlite3_vtab_on_conflict (sqlite3 *)

SQLITE_API SQLITE_EXPERIMENTAL int SQLITE_STDCALL	sqlite3_stmt_scanstatus (sqlite3_stmt pStmt, int idx, int iScanStatusOp, void pOut)

SQLITE_API SQLITE_EXPERIMENTAL void SQLITE_STDCALL	sqlite3_stmt_scanstatus_reset (sqlite3_stmt *)

SQLITE_API int SQLITE_STDCALL	sqlite3_rtree_geometry_callback (sqlite3 db, const char zGeom, int(xGeom)(sqlite3_rtree_geometry , int, sqlite3_rtree_dbl , int ), void *pContext)

SQLITE_API int SQLITE_STDCALL	sqlite3_rtree_query_callback (sqlite3 db, const char zQueryFunc, int(xQueryFunc)(sqlite3_rtree_query_info ), void pContext, void(xDestructor)(void *))

SQLITE_PRIVATE void	sqlite3HashInit (Hash *)

SQLITE_PRIVATE void *	sqlite3HashInsert (Hash , const char pKey, void *pData)

SQLITE_PRIVATE void *	sqlite3HashFind (const Hash , const char pKey)

SQLITE_PRIVATE void	sqlite3HashClear (Hash *)

SQLITE_PRIVATE int	sqlite3BtreeOpen (sqlite3_vfs pVfs, const char zFilename, sqlite3 db, Btree *ppBtree, int flags, int vfsFlags)

SQLITE_PRIVATE int	sqlite3BtreeClose (Btree *)

SQLITE_PRIVATE int	sqlite3BtreeSetCacheSize (Btree *, int)

SQLITE_PRIVATE int	sqlite3BtreeSetPagerFlags (Btree *, unsigned)

SQLITE_PRIVATE int	sqlite3BtreeSyncDisabled (Btree *)

SQLITE_PRIVATE int	sqlite3BtreeSetPageSize (Btree *p, int nPagesize, int nReserve, int eFix)

SQLITE_PRIVATE int	sqlite3BtreeGetPageSize (Btree *)

SQLITE_PRIVATE int	sqlite3BtreeMaxPageCount (Btree *, int)

SQLITE_PRIVATE u32	sqlite3BtreeLastPage (Btree *)

SQLITE_PRIVATE int	sqlite3BtreeSecureDelete (Btree *, int)

SQLITE_PRIVATE int	sqlite3BtreeGetOptimalReserve (Btree *)

SQLITE_PRIVATE int	sqlite3BtreeGetReserveNoMutex (Btree *p)

SQLITE_PRIVATE int	sqlite3BtreeSetAutoVacuum (Btree *, int)

SQLITE_PRIVATE int	sqlite3BtreeGetAutoVacuum (Btree *)

SQLITE_PRIVATE int	sqlite3BtreeBeginTrans (Btree *, int)

SQLITE_PRIVATE int	sqlite3BtreeCommitPhaseOne (Btree , const char zMaster)

SQLITE_PRIVATE int	sqlite3BtreeCommitPhaseTwo (Btree *, int)

SQLITE_PRIVATE int	sqlite3BtreeCommit (Btree *)

SQLITE_PRIVATE int	sqlite3BtreeRollback (Btree *, int, int)

SQLITE_PRIVATE int	sqlite3BtreeBeginStmt (Btree *, int)

SQLITE_PRIVATE int	sqlite3BtreeCreateTable (Btree , int , int flags)

SQLITE_PRIVATE int	sqlite3BtreeIsInTrans (Btree *)

SQLITE_PRIVATE int	sqlite3BtreeIsInReadTrans (Btree *)

SQLITE_PRIVATE int	sqlite3BtreeIsInBackup (Btree *)

SQLITE_PRIVATE void *	sqlite3BtreeSchema (Btree , int, void()(void *))

SQLITE_PRIVATE int	sqlite3BtreeSchemaLocked (Btree *pBtree)

SQLITE_PRIVATE int	sqlite3BtreeLockTable (Btree *pBtree, int iTab, u8 isWriteLock)

SQLITE_PRIVATE int	sqlite3BtreeSavepoint (Btree *, int, int)

SQLITE_PRIVATE const char *	sqlite3BtreeGetFilename (Btree *)

SQLITE_PRIVATE const char *	sqlite3BtreeGetJournalname (Btree *)

SQLITE_PRIVATE int	sqlite3BtreeCopyFile (Btree , Btree )

SQLITE_PRIVATE int	sqlite3BtreeIncrVacuum (Btree *)

SQLITE_PRIVATE int	sqlite3BtreeDropTable (Btree , int, int )

SQLITE_PRIVATE int	sqlite3BtreeClearTable (Btree , int, int )

SQLITE_PRIVATE int	sqlite3BtreeClearTableOfCursor (BtCursor *)

SQLITE_PRIVATE int	sqlite3BtreeTripAllCursors (Btree *, int, int)

SQLITE_PRIVATE void	sqlite3BtreeGetMeta (Btree pBtree, int idx, u32 pValue)

SQLITE_PRIVATE int	sqlite3BtreeUpdateMeta (Btree *, int idx, u32 value)

SQLITE_PRIVATE int	sqlite3BtreeNewDb (Btree *p)

SQLITE_PRIVATE int	sqlite3BtreeCursor (Btree , int iTable, int wrFlag, struct KeyInfo , BtCursor *pCursor)

SQLITE_PRIVATE int	sqlite3BtreeCursorSize (void)

SQLITE_PRIVATE void	sqlite3BtreeCursorZero (BtCursor *)

SQLITE_PRIVATE int	sqlite3BtreeCloseCursor (BtCursor *)

SQLITE_PRIVATE int	sqlite3BtreeMovetoUnpacked (BtCursor , UnpackedRecord pUnKey, i64 intKey, int bias, int *pRes)

SQLITE_PRIVATE int	sqlite3BtreeCursorHasMoved (BtCursor *)

SQLITE_PRIVATE int	sqlite3BtreeCursorRestore (BtCursor , int )

SQLITE_PRIVATE int	sqlite3BtreeDelete (BtCursor *)

SQLITE_PRIVATE int	sqlite3BtreeInsert (BtCursor , const void pKey, i64 nKey, const void *pData, int nData, int nZero, int bias, int seekResult)

SQLITE_PRIVATE int	sqlite3BtreeFirst (BtCursor , int pRes)

SQLITE_PRIVATE int	sqlite3BtreeLast (BtCursor , int pRes)

SQLITE_PRIVATE int	sqlite3BtreeNext (BtCursor , int pRes)

SQLITE_PRIVATE int	sqlite3BtreeEof (BtCursor *)

SQLITE_PRIVATE int	sqlite3BtreePrevious (BtCursor , int pRes)

SQLITE_PRIVATE int	sqlite3BtreeKeySize (BtCursor , i64 pSize)

SQLITE_PRIVATE int	sqlite3BtreeKey (BtCursor , u32 offset, u32 amt, void )

SQLITE_PRIVATE const void *	sqlite3BtreeKeyFetch (BtCursor , u32 pAmt)

SQLITE_PRIVATE const void *	sqlite3BtreeDataFetch (BtCursor , u32 pAmt)

SQLITE_PRIVATE int	sqlite3BtreeDataSize (BtCursor , u32 pSize)

SQLITE_PRIVATE int	sqlite3BtreeData (BtCursor , u32 offset, u32 amt, void )

SQLITE_PRIVATE char *	sqlite3BtreeIntegrityCheck (Btree , int aRoot, int nRoot, int, int *)

SQLITE_PRIVATE struct Pager *	sqlite3BtreePager (Btree *)

SQLITE_PRIVATE int	sqlite3BtreePutData (BtCursor , u32 offset, u32 amt, void )

SQLITE_PRIVATE void	sqlite3BtreeIncrblobCursor (BtCursor *)

SQLITE_PRIVATE void	sqlite3BtreeClearCursor (BtCursor *)

SQLITE_PRIVATE int	sqlite3BtreeSetVersion (Btree *pBt, int iVersion)

SQLITE_PRIVATE void	sqlite3BtreeCursorHints (BtCursor *, unsigned int mask)

SQLITE_PRIVATE int	sqlite3BtreeIsReadonly (Btree *pBt)

SQLITE_PRIVATE int	sqlite3HeaderSizeBtree (void)

SQLITE_PRIVATE int	sqlite3BtreeCount (BtCursor , i64 )

SQLITE_PRIVATE int	sqlite3BtreeCheckpoint (Btree , int, int , int *)

SQLITE_PRIVATE void	sqlite3BtreeEnter (Btree *)

SQLITE_PRIVATE void	sqlite3BtreeEnterAll (sqlite3 *)

SQLITE_PRIVATE int	sqlite3BtreeSharable (Btree *)

SQLITE_PRIVATE void	sqlite3BtreeLeave (Btree *)

SQLITE_PRIVATE void	sqlite3BtreeEnterCursor (BtCursor *)

SQLITE_PRIVATE void	sqlite3BtreeLeaveCursor (BtCursor *)

SQLITE_PRIVATE void	sqlite3BtreeLeaveAll (sqlite3 *)

SQLITE_PRIVATE Vdbe *	sqlite3VdbeCreate (Parse *)

SQLITE_PRIVATE int	sqlite3VdbeAddOp0 (Vdbe *, int)

SQLITE_PRIVATE int	sqlite3VdbeAddOp1 (Vdbe *, int, int)

SQLITE_PRIVATE int	sqlite3VdbeAddOp2 (Vdbe *, int, int, int)

SQLITE_PRIVATE int	sqlite3VdbeAddOp3 (Vdbe *, int, int, int, int)

SQLITE_PRIVATE int	sqlite3VdbeAddOp4 (Vdbe , int, int, int, int, const char zP4, int)

SQLITE_PRIVATE int	sqlite3VdbeAddOp4Int (Vdbe *, int, int, int, int, int)

SQLITE_PRIVATE int	sqlite3VdbeAddOpList (Vdbe , int nOp, VdbeOpList const aOp, int iLineno)

SQLITE_PRIVATE void	sqlite3VdbeAddParseSchemaOp (Vdbe , int, char )

SQLITE_PRIVATE void	sqlite3VdbeChangeP1 (Vdbe *, u32 addr, int P1)

SQLITE_PRIVATE void	sqlite3VdbeChangeP2 (Vdbe *, u32 addr, int P2)

SQLITE_PRIVATE void	sqlite3VdbeChangeP3 (Vdbe *, u32 addr, int P3)

SQLITE_PRIVATE void	sqlite3VdbeChangeP5 (Vdbe *, u8 P5)

SQLITE_PRIVATE void	sqlite3VdbeJumpHere (Vdbe *, int addr)

SQLITE_PRIVATE void	sqlite3VdbeChangeToNoop (Vdbe *, int addr)

SQLITE_PRIVATE int	sqlite3VdbeDeletePriorOpcode (Vdbe *, u8 op)

SQLITE_PRIVATE void	sqlite3VdbeChangeP4 (Vdbe , int addr, const char zP4, int N)

SQLITE_PRIVATE void	sqlite3VdbeSetP4KeyInfo (Parse , Index )

SQLITE_PRIVATE void	sqlite3VdbeUsesBtree (Vdbe *, int)

SQLITE_PRIVATE VdbeOp *	sqlite3VdbeGetOp (Vdbe *, int)

SQLITE_PRIVATE int	sqlite3VdbeMakeLabel (Vdbe *)

SQLITE_PRIVATE void	sqlite3VdbeRunOnlyOnce (Vdbe *)

SQLITE_PRIVATE void	sqlite3VdbeDelete (Vdbe *)

SQLITE_PRIVATE void	sqlite3VdbeClearObject (sqlite3 , Vdbe )

SQLITE_PRIVATE void	sqlite3VdbeMakeReady (Vdbe , Parse )

SQLITE_PRIVATE int	sqlite3VdbeFinalize (Vdbe *)

SQLITE_PRIVATE void	sqlite3VdbeResolveLabel (Vdbe *, int)

SQLITE_PRIVATE int	sqlite3VdbeCurrentAddr (Vdbe *)

SQLITE_PRIVATE void	sqlite3VdbeResetStepResult (Vdbe *)

SQLITE_PRIVATE void	sqlite3VdbeRewind (Vdbe *)

SQLITE_PRIVATE int	sqlite3VdbeReset (Vdbe *)

SQLITE_PRIVATE void	sqlite3VdbeSetNumCols (Vdbe *, int)

SQLITE_PRIVATE int	sqlite3VdbeSetColName (Vdbe , int, int, const char , void()(void ))

SQLITE_PRIVATE void	sqlite3VdbeCountChanges (Vdbe *)

SQLITE_PRIVATE sqlite3 *	sqlite3VdbeDb (Vdbe *)

SQLITE_PRIVATE void	sqlite3VdbeSetSql (Vdbe , const char z, int n, int)

SQLITE_PRIVATE void	sqlite3VdbeSwap (Vdbe , Vdbe )

SQLITE_PRIVATE VdbeOp *	sqlite3VdbeTakeOpArray (Vdbe , int , int *)

SQLITE_PRIVATE sqlite3_value *	sqlite3VdbeGetBoundValue (Vdbe *, int, u8)

SQLITE_PRIVATE void	sqlite3VdbeSetVarmask (Vdbe *, int)

SQLITE_PRIVATE char *	sqlite3VdbeExpandSql (Vdbe , const char )

SQLITE_PRIVATE int	sqlite3MemCompare (const Mem , const Mem , const CollSeq *)

SQLITE_PRIVATE void	sqlite3VdbeRecordUnpack (KeyInfo , int, const void , UnpackedRecord *)

SQLITE_PRIVATE int	sqlite3VdbeRecordCompare (int, const void , UnpackedRecord )

SQLITE_PRIVATE int	sqlite3VdbeRecordCompareWithSkip (int, const void , UnpackedRecord , int)

SQLITE_PRIVATE UnpackedRecord *	sqlite3VdbeAllocUnpackedRecord (KeyInfo , char , int, char **)

SQLITE_PRIVATE RecordCompare	sqlite3VdbeFindCompare (UnpackedRecord *)

SQLITE_PRIVATE void	sqlite3VdbeLinkSubProgram (Vdbe , SubProgram )

SQLITE_PRIVATE int	sqlite3PagerOpen (sqlite3_vfs , Pager ppPager, const char , int, int, int, void()(DbPage ))

SQLITE_PRIVATE int	sqlite3PagerClose (Pager *pPager)

SQLITE_PRIVATE int	sqlite3PagerReadFileheader (Pager , int, unsigned char )

SQLITE_PRIVATE void	sqlite3PagerSetBusyhandler (Pager , int()(void ), void )

SQLITE_PRIVATE int	sqlite3PagerSetPagesize (Pager , u32 , int)

SQLITE_PRIVATE int	sqlite3PagerMaxPageCount (Pager *, int)

SQLITE_PRIVATE void	sqlite3PagerSetCachesize (Pager *, int)

SQLITE_PRIVATE void	sqlite3PagerSetMmapLimit (Pager *, sqlite3_int64)

SQLITE_PRIVATE void	sqlite3PagerShrink (Pager *)

SQLITE_PRIVATE void	sqlite3PagerSetFlags (Pager *, unsigned)

SQLITE_PRIVATE int	sqlite3PagerLockingMode (Pager *, int)

SQLITE_PRIVATE int	sqlite3PagerSetJournalMode (Pager *, int)

SQLITE_PRIVATE int	sqlite3PagerGetJournalMode (Pager *)

SQLITE_PRIVATE int	sqlite3PagerOkToChangeJournalMode (Pager *)

SQLITE_PRIVATE i64	sqlite3PagerJournalSizeLimit (Pager *, i64)

SQLITE_PRIVATE sqlite3_backup **	sqlite3PagerBackupPtr (Pager *)

SQLITE_PRIVATE int	sqlite3PagerAcquire (Pager pPager, Pgno pgno, DbPage *ppPage, int clrFlag)

SQLITE_PRIVATE DbPage *	sqlite3PagerLookup (Pager *pPager, Pgno pgno)

SQLITE_PRIVATE void	sqlite3PagerRef (DbPage *)

SQLITE_PRIVATE void	sqlite3PagerUnref (DbPage *)

SQLITE_PRIVATE void	sqlite3PagerUnrefNotNull (DbPage *)

SQLITE_PRIVATE int	sqlite3PagerWrite (DbPage *)

SQLITE_PRIVATE void	sqlite3PagerDontWrite (DbPage *)

SQLITE_PRIVATE int	sqlite3PagerMovepage (Pager , DbPage , Pgno, int)

SQLITE_PRIVATE int	sqlite3PagerPageRefcount (DbPage *)

SQLITE_PRIVATE void *	sqlite3PagerGetData (DbPage *)

SQLITE_PRIVATE void *	sqlite3PagerGetExtra (DbPage *)

SQLITE_PRIVATE void	sqlite3PagerPagecount (Pager , int )

SQLITE_PRIVATE int	sqlite3PagerBegin (Pager *, int exFlag, int)

SQLITE_PRIVATE int	sqlite3PagerCommitPhaseOne (Pager , const char zMaster, int)

SQLITE_PRIVATE int	sqlite3PagerExclusiveLock (Pager *)

SQLITE_PRIVATE int	sqlite3PagerSync (Pager pPager, const char zMaster)

SQLITE_PRIVATE int	sqlite3PagerCommitPhaseTwo (Pager *)

SQLITE_PRIVATE int	sqlite3PagerRollback (Pager *)

SQLITE_PRIVATE int	sqlite3PagerOpenSavepoint (Pager *pPager, int n)

SQLITE_PRIVATE int	sqlite3PagerSavepoint (Pager *pPager, int op, int iSavepoint)

SQLITE_PRIVATE int	sqlite3PagerSharedLock (Pager *pPager)

SQLITE_PRIVATE int	sqlite3PagerCheckpoint (Pager pPager, int, int , int *)

SQLITE_PRIVATE int	sqlite3PagerWalSupported (Pager *pPager)

SQLITE_PRIVATE int	sqlite3PagerWalCallback (Pager *pPager)

SQLITE_PRIVATE int	sqlite3PagerOpenWal (Pager pPager, int pisOpen)

SQLITE_PRIVATE int	sqlite3PagerCloseWal (Pager *pPager)

SQLITE_PRIVATE u8	sqlite3PagerIsreadonly (Pager *)

SQLITE_PRIVATE u32	sqlite3PagerDataVersion (Pager *)

SQLITE_PRIVATE int	sqlite3PagerRefcount (Pager *)

SQLITE_PRIVATE int	sqlite3PagerMemUsed (Pager *)

SQLITE_PRIVATE const char *	sqlite3PagerFilename (Pager *, int)

SQLITE_PRIVATE const sqlite3_vfs *	sqlite3PagerVfs (Pager *)

SQLITE_PRIVATE sqlite3_file *	sqlite3PagerFile (Pager *)

SQLITE_PRIVATE const char *	sqlite3PagerJournalname (Pager *)

SQLITE_PRIVATE int	sqlite3PagerNosync (Pager *)

SQLITE_PRIVATE void *	sqlite3PagerTempSpace (Pager *)

SQLITE_PRIVATE int	sqlite3PagerIsMemdb (Pager *)

SQLITE_PRIVATE void	sqlite3PagerCacheStat (Pager , int, int, int )

SQLITE_PRIVATE void	sqlite3PagerClearCache (Pager *)

SQLITE_PRIVATE int	sqlite3SectorSize (sqlite3_file *)

SQLITE_PRIVATE void	sqlite3PagerTruncateImage (Pager *, Pgno)

SQLITE_PRIVATE void	sqlite3PagerRekey (DbPage *, Pgno, u16)

SQLITE_PRIVATE int	sqlite3PcacheInitialize (void)

SQLITE_PRIVATE void	sqlite3PcacheShutdown (void)

SQLITE_PRIVATE void	sqlite3PCacheBufferSetup (void *, int sz, int n)

SQLITE_PRIVATE int	sqlite3PcacheOpen (int szPage, int szExtra, int bPurgeable, int(xStress)(void , PgHdr ), void pStress, PCache *pToInit)

SQLITE_PRIVATE int	sqlite3PcacheSetPageSize (PCache *, int)

SQLITE_PRIVATE int	sqlite3PcacheSize (void)

SQLITE_PRIVATE sqlite3_pcache_page *	sqlite3PcacheFetch (PCache *, Pgno, int createFlag)

SQLITE_PRIVATE int	sqlite3PcacheFetchStress (PCache , Pgno, sqlite3_pcache_page *)

SQLITE_PRIVATE PgHdr *	sqlite3PcacheFetchFinish (PCache , Pgno, sqlite3_pcache_page pPage)

SQLITE_PRIVATE void	sqlite3PcacheRelease (PgHdr *)

SQLITE_PRIVATE void	sqlite3PcacheDrop (PgHdr *)

SQLITE_PRIVATE void	sqlite3PcacheMakeDirty (PgHdr *)

SQLITE_PRIVATE void	sqlite3PcacheMakeClean (PgHdr *)

SQLITE_PRIVATE void	sqlite3PcacheCleanAll (PCache *)

SQLITE_PRIVATE void	sqlite3PcacheMove (PgHdr *, Pgno)

SQLITE_PRIVATE void	sqlite3PcacheTruncate (PCache *, Pgno x)

SQLITE_PRIVATE PgHdr *	sqlite3PcacheDirtyList (PCache *)

SQLITE_PRIVATE void	sqlite3PcacheClose (PCache *)

SQLITE_PRIVATE void	sqlite3PcacheClearSyncFlags (PCache *)

SQLITE_PRIVATE void	sqlite3PcacheClear (PCache *)

SQLITE_PRIVATE int	sqlite3PcacheRefCount (PCache *)

SQLITE_PRIVATE void	sqlite3PcacheRef (PgHdr *)

SQLITE_PRIVATE int	sqlite3PcachePageRefcount (PgHdr *)

SQLITE_PRIVATE int	sqlite3PcachePagecount (PCache *)

SQLITE_PRIVATE void	sqlite3PcacheSetCachesize (PCache *, int)

SQLITE_PRIVATE void	sqlite3PcacheShrink (PCache *)

SQLITE_PRIVATE void	sqlite3PCacheSetDefault (void)

SQLITE_PRIVATE int	sqlite3HeaderSizePcache (void)

SQLITE_PRIVATE int	sqlite3HeaderSizePcache1 (void)

SQLITE_PRIVATE int	sqlite3OsInit (void)

SQLITE_PRIVATE int	sqlite3OsClose (sqlite3_file *)

SQLITE_PRIVATE int	sqlite3OsRead (sqlite3_file , void , int amt, i64 offset)

SQLITE_PRIVATE int	sqlite3OsWrite (sqlite3_file , const void , int amt, i64 offset)

SQLITE_PRIVATE int	sqlite3OsTruncate (sqlite3_file *, i64 size)

SQLITE_PRIVATE int	sqlite3OsSync (sqlite3_file *, int)

SQLITE_PRIVATE int	sqlite3OsFileSize (sqlite3_file , i64 pSize)

SQLITE_PRIVATE int	sqlite3OsLock (sqlite3_file *, int)

SQLITE_PRIVATE int	sqlite3OsUnlock (sqlite3_file *, int)

SQLITE_PRIVATE int	sqlite3OsCheckReservedLock (sqlite3_file id, int pResOut)

SQLITE_PRIVATE int	sqlite3OsFileControl (sqlite3_file , int, void )

SQLITE_PRIVATE void	sqlite3OsFileControlHint (sqlite3_file , int, void )

SQLITE_PRIVATE int	sqlite3OsSectorSize (sqlite3_file *id)

SQLITE_PRIVATE int	sqlite3OsDeviceCharacteristics (sqlite3_file *id)

SQLITE_PRIVATE int	sqlite3OsShmMap (sqlite3_file , int, int, int, void volatile *)

SQLITE_PRIVATE int	sqlite3OsShmLock (sqlite3_file *id, int, int, int)

SQLITE_PRIVATE void	sqlite3OsShmBarrier (sqlite3_file *id)

SQLITE_PRIVATE int	sqlite3OsShmUnmap (sqlite3_file *id, int)

SQLITE_PRIVATE int	sqlite3OsFetch (sqlite3_file id, i64, int, void *)

SQLITE_PRIVATE int	sqlite3OsUnfetch (sqlite3_file , i64, void )

SQLITE_PRIVATE int	sqlite3OsOpen (sqlite3_vfs , const char , sqlite3_file , int, int )

SQLITE_PRIVATE int	sqlite3OsDelete (sqlite3_vfs , const char , int)

SQLITE_PRIVATE int	sqlite3OsAccess (sqlite3_vfs , const char , int, int *pResOut)

SQLITE_PRIVATE int	sqlite3OsFullPathname (sqlite3_vfs , const char , int, char *)

SQLITE_PRIVATE void *	sqlite3OsDlOpen (sqlite3_vfs , const char )

SQLITE_PRIVATE void	sqlite3OsDlError (sqlite3_vfs , int, char )

SQLITE_PRIVATE void	sqlite3OsDlClose (sqlite3_vfs , void )

SQLITE_PRIVATE int	sqlite3OsRandomness (sqlite3_vfs , int, char )

SQLITE_PRIVATE int	sqlite3OsSleep (sqlite3_vfs *, int)

SQLITE_PRIVATE int	sqlite3OsCurrentTimeInt64 (sqlite3_vfs , sqlite3_int64 )

SQLITE_PRIVATE int	sqlite3OsOpenMalloc (sqlite3_vfs , const char , sqlite3_file *, int, int )

SQLITE_PRIVATE int	sqlite3OsCloseFree (sqlite3_file *)

SQLITE_PRIVATE int	sqlite3WalkExpr (Walker , Expr )

SQLITE_PRIVATE int	sqlite3WalkExprList (Walker , ExprList )

SQLITE_PRIVATE int	sqlite3WalkSelect (Walker , Select )

SQLITE_PRIVATE int	sqlite3WalkSelectExpr (Walker , Select )

SQLITE_PRIVATE int	sqlite3WalkSelectFrom (Walker , Select )

SQLITE_PRIVATE int	sqlite3CorruptError (int)

SQLITE_PRIVATE int	sqlite3MisuseError (int)

SQLITE_PRIVATE int	sqlite3CantopenError (int)

SQLITE_PRIVATE int	sqlite3IsIdChar (u8)

SQLITE_PRIVATE int	sqlite3Strlen30 (const char *)

SQLITE_PRIVATE int	sqlite3MallocInit (void)

SQLITE_PRIVATE void	sqlite3MallocEnd (void)

SQLITE_PRIVATE void *	sqlite3Malloc (u64)

SQLITE_PRIVATE void *	sqlite3MallocZero (u64)

SQLITE_PRIVATE void *	sqlite3DbMallocZero (sqlite3 *, u64)

SQLITE_PRIVATE void *	sqlite3DbMallocRaw (sqlite3 *, u64)

SQLITE_PRIVATE char *	sqlite3DbStrDup (sqlite3 , const char )

SQLITE_PRIVATE char *	sqlite3DbStrNDup (sqlite3 , const char , u64)

SQLITE_PRIVATE void *	sqlite3Realloc (void *, u64)

SQLITE_PRIVATE void *	sqlite3DbReallocOrFree (sqlite3 , void , u64)

SQLITE_PRIVATE void *	sqlite3DbRealloc (sqlite3 , void , u64)

SQLITE_PRIVATE void	sqlite3DbFree (sqlite3 , void )

SQLITE_PRIVATE int	sqlite3MallocSize (void *)

SQLITE_PRIVATE int	sqlite3DbMallocSize (sqlite3 , void )

SQLITE_PRIVATE void *	sqlite3ScratchMalloc (int)

SQLITE_PRIVATE void	sqlite3ScratchFree (void *)

SQLITE_PRIVATE void *	sqlite3PageMalloc (int)

SQLITE_PRIVATE void	sqlite3PageFree (void *)

SQLITE_PRIVATE void	sqlite3MemSetDefault (void)

SQLITE_PRIVATE void	sqlite3BenignMallocHooks (void()(void), void()(void))

SQLITE_PRIVATE int	sqlite3HeapNearlyFull (void)

SQLITE_PRIVATE sqlite3_mutex_methods const *	sqlite3DefaultMutex (void)

SQLITE_PRIVATE sqlite3_mutex_methods const *	sqlite3NoopMutex (void)

SQLITE_PRIVATE sqlite3_mutex *	sqlite3MutexAlloc (int)

SQLITE_PRIVATE int	sqlite3MutexInit (void)

SQLITE_PRIVATE int	sqlite3MutexEnd (void)

SQLITE_PRIVATE sqlite3_int64	sqlite3StatusValue (int)

SQLITE_PRIVATE void	sqlite3StatusUp (int, int)

SQLITE_PRIVATE void	sqlite3StatusDown (int, int)

SQLITE_PRIVATE void	sqlite3StatusSet (int, int)

SQLITE_PRIVATE sqlite3_mutex *	sqlite3Pcache1Mutex (void)

SQLITE_PRIVATE sqlite3_mutex *	sqlite3MallocMutex (void)

SQLITE_PRIVATE int	sqlite3IsNaN (double)

SQLITE_PRIVATE void	sqlite3VXPrintf (StrAccum , u32, const char , va_list)

SQLITE_PRIVATE void	sqlite3XPrintf (StrAccum , u32, const char ,...)

SQLITE_PRIVATE char *	sqlite3MPrintf (sqlite3 , const char ,...)

SQLITE_PRIVATE char *	sqlite3VMPrintf (sqlite3 , const char , va_list)

SQLITE_PRIVATE char *	sqlite3MAppendf (sqlite3 , char , const char *,...)

SQLITE_PRIVATE void	sqlite3SetString (char *, sqlite3 , const char *,...)

SQLITE_PRIVATE void	sqlite3ErrorMsg (Parse , const char ,...)

SQLITE_PRIVATE int	sqlite3Dequote (char *)

SQLITE_PRIVATE int	sqlite3KeywordCode (const unsigned char *, int)

SQLITE_PRIVATE int	sqlite3RunParser (Parse , const char , char **)

SQLITE_PRIVATE void	sqlite3FinishCoding (Parse *)

SQLITE_PRIVATE int	sqlite3GetTempReg (Parse *)

SQLITE_PRIVATE void	sqlite3ReleaseTempReg (Parse *, int)

SQLITE_PRIVATE int	sqlite3GetTempRange (Parse *, int)

SQLITE_PRIVATE void	sqlite3ReleaseTempRange (Parse *, int, int)

SQLITE_PRIVATE void	sqlite3ClearTempRegCache (Parse *)

SQLITE_PRIVATE Expr *	sqlite3ExprAlloc (sqlite3 , int, const Token , int)

SQLITE_PRIVATE Expr *	sqlite3Expr (sqlite3 , int, const char )

SQLITE_PRIVATE void	sqlite3ExprAttachSubtrees (sqlite3 , Expr , Expr , Expr )

SQLITE_PRIVATE Expr *	sqlite3PExpr (Parse , int, Expr , Expr , const Token )

SQLITE_PRIVATE Expr *	sqlite3ExprAnd (sqlite3 , Expr , Expr *)

SQLITE_PRIVATE Expr *	sqlite3ExprFunction (Parse , ExprList , Token *)

SQLITE_PRIVATE void	sqlite3ExprAssignVarNumber (Parse , Expr )

SQLITE_PRIVATE void	sqlite3ExprDelete (sqlite3 , Expr )

SQLITE_PRIVATE ExprList *	sqlite3ExprListAppend (Parse , ExprList , Expr *)

SQLITE_PRIVATE void	sqlite3ExprListSetName (Parse , ExprList , Token *, int)

SQLITE_PRIVATE void	sqlite3ExprListSetSpan (Parse , ExprList , ExprSpan *)

SQLITE_PRIVATE void	sqlite3ExprListDelete (sqlite3 , ExprList )

SQLITE_PRIVATE u32	sqlite3ExprListFlags (const ExprList *)

SQLITE_PRIVATE int	sqlite3Init (sqlite3 , char *)

SQLITE_PRIVATE int	sqlite3InitCallback (void , int, char , char *)

SQLITE_PRIVATE void	sqlite3Pragma (Parse , Token , Token , Token , int)

SQLITE_PRIVATE void	sqlite3ResetAllSchemasOfConnection (sqlite3 *)

SQLITE_PRIVATE void	sqlite3ResetOneSchema (sqlite3 *, int)

SQLITE_PRIVATE void	sqlite3CollapseDatabaseArray (sqlite3 *)

SQLITE_PRIVATE void	sqlite3BeginParse (Parse *, int)

SQLITE_PRIVATE void	sqlite3CommitInternalChanges (sqlite3 *)

SQLITE_PRIVATE Table *	sqlite3ResultSetOfSelect (Parse , Select )

SQLITE_PRIVATE void	sqlite3OpenMasterTable (Parse *, int)

SQLITE_PRIVATE Index *	sqlite3PrimaryKeyIndex (Table *)

SQLITE_PRIVATE i16	sqlite3ColumnOfIndex (Index *, i16)

SQLITE_PRIVATE void	sqlite3StartTable (Parse , Token , Token *, int, int, int, int)

SQLITE_PRIVATE void	sqlite3AddColumn (Parse , Token )

SQLITE_PRIVATE void	sqlite3AddNotNull (Parse *, int)

SQLITE_PRIVATE void	sqlite3AddPrimaryKey (Parse , ExprList , int, int, int)

SQLITE_PRIVATE void	sqlite3AddCheckConstraint (Parse , Expr )

SQLITE_PRIVATE void	sqlite3AddColumnType (Parse , Token )

SQLITE_PRIVATE void	sqlite3AddDefaultValue (Parse , ExprSpan )

SQLITE_PRIVATE void	sqlite3AddCollateType (Parse , Token )

SQLITE_PRIVATE void	sqlite3EndTable (Parse , Token , Token , u8, Select )

SQLITE_PRIVATE int	sqlite3ParseUri (const char , const char , unsigned int , sqlite3_vfs , char , char *)

SQLITE_PRIVATE Btree *	sqlite3DbNameToBtree (sqlite3 , const char )

SQLITE_PRIVATE int	sqlite3CodeOnce (Parse *)

SQLITE_PRIVATE int	sqlite3FaultSim (int)

SQLITE_PRIVATE Bitvec *	sqlite3BitvecCreate (u32)

SQLITE_PRIVATE int	sqlite3BitvecTest (Bitvec *, u32)

SQLITE_PRIVATE int	sqlite3BitvecSet (Bitvec *, u32)

SQLITE_PRIVATE void	sqlite3BitvecClear (Bitvec , u32, void )

SQLITE_PRIVATE void	sqlite3BitvecDestroy (Bitvec *)

SQLITE_PRIVATE u32	sqlite3BitvecSize (Bitvec *)

SQLITE_PRIVATE int	sqlite3BitvecBuiltinTest (int, int *)

SQLITE_PRIVATE RowSet *	sqlite3RowSetInit (sqlite3 , void , unsigned int)

SQLITE_PRIVATE void	sqlite3RowSetClear (RowSet *)

SQLITE_PRIVATE void	sqlite3RowSetInsert (RowSet *, i64)

SQLITE_PRIVATE int	sqlite3RowSetTest (RowSet *, int iBatch, i64)

SQLITE_PRIVATE int	sqlite3RowSetNext (RowSet , i64 )

SQLITE_PRIVATE void	sqlite3CreateView (Parse , Token , Token , Token , Select *, int, int)

SQLITE_PRIVATE int	sqlite3ViewGetColumnNames (Parse , Table )

SQLITE_PRIVATE void	sqlite3DropTable (Parse , SrcList , int, int)

SQLITE_PRIVATE void	sqlite3CodeDropTable (Parse , Table , int, int)

SQLITE_PRIVATE void	sqlite3DeleteTable (sqlite3 , Table )

SQLITE_PRIVATE void	sqlite3AutoincrementBegin (Parse *pParse)

SQLITE_PRIVATE void	sqlite3AutoincrementEnd (Parse *pParse)

SQLITE_PRIVATE void	sqlite3Insert (Parse , SrcList , Select , IdList , int)

SQLITE_PRIVATE void *	sqlite3ArrayAllocate (sqlite3 , void , int, int , int )

SQLITE_PRIVATE IdList *	sqlite3IdListAppend (sqlite3 , IdList , Token *)

SQLITE_PRIVATE int	sqlite3IdListIndex (IdList , const char )

SQLITE_PRIVATE SrcList *	sqlite3SrcListEnlarge (sqlite3 , SrcList , int, int)

SQLITE_PRIVATE SrcList *	sqlite3SrcListAppend (sqlite3 , SrcList , Token , Token )

SQLITE_PRIVATE SrcList *	sqlite3SrcListAppendFromTerm (Parse , SrcList , Token , Token , Token , Select , Expr , IdList )

SQLITE_PRIVATE void	sqlite3SrcListIndexedBy (Parse , SrcList , Token *)

SQLITE_PRIVATE int	sqlite3IndexedByLookup (Parse , struct SrcList_item )

SQLITE_PRIVATE void	sqlite3SrcListShiftJoinType (SrcList *)

SQLITE_PRIVATE void	sqlite3SrcListAssignCursors (Parse , SrcList )

SQLITE_PRIVATE void	sqlite3IdListDelete (sqlite3 , IdList )

SQLITE_PRIVATE void	sqlite3SrcListDelete (sqlite3 , SrcList )

SQLITE_PRIVATE Index *	sqlite3AllocateIndexObject (sqlite3 , i16, int, char *)

SQLITE_PRIVATE Index *	sqlite3CreateIndex (Parse , Token , Token , SrcList , ExprList , int, Token , Expr *, int, int)

SQLITE_PRIVATE void	sqlite3DropIndex (Parse , SrcList , int)

SQLITE_PRIVATE int	sqlite3Select (Parse , Select , SelectDest *)

SQLITE_PRIVATE Select *	sqlite3SelectNew (Parse , ExprList , SrcList , Expr , ExprList , Expr , ExprList , u16, Expr , Expr *)

SQLITE_PRIVATE void	sqlite3SelectDelete (sqlite3 , Select )

SQLITE_PRIVATE Table *	sqlite3SrcListLookup (Parse , SrcList )

SQLITE_PRIVATE int	sqlite3IsReadOnly (Parse , Table , int)

SQLITE_PRIVATE void	sqlite3OpenTable (Parse , int iCur, int iDb, Table , int)

SQLITE_PRIVATE void	sqlite3DeleteFrom (Parse , SrcList , Expr *)

SQLITE_PRIVATE void	sqlite3Update (Parse , SrcList , ExprList , Expr , int)

SQLITE_PRIVATE WhereInfo *	sqlite3WhereBegin (Parse , SrcList , Expr , ExprList , ExprList *, u16, int)

SQLITE_PRIVATE void	sqlite3WhereEnd (WhereInfo *)

SQLITE_PRIVATE u64	sqlite3WhereOutputRowCount (WhereInfo *)

SQLITE_PRIVATE int	sqlite3WhereIsDistinct (WhereInfo *)

SQLITE_PRIVATE int	sqlite3WhereIsOrdered (WhereInfo *)

SQLITE_PRIVATE int	sqlite3WhereIsSorted (WhereInfo *)

SQLITE_PRIVATE int	sqlite3WhereContinueLabel (WhereInfo *)

SQLITE_PRIVATE int	sqlite3WhereBreakLabel (WhereInfo *)

SQLITE_PRIVATE int	sqlite3WhereOkOnePass (WhereInfo , int )

SQLITE_PRIVATE int	sqlite3ExprCodeGetColumn (Parse , Table , int, int, int, u8)

SQLITE_PRIVATE void	sqlite3ExprCodeGetColumnOfTable (Vdbe , Table , int, int, int)

SQLITE_PRIVATE void	sqlite3ExprCodeMove (Parse *, int, int, int)

SQLITE_PRIVATE void	sqlite3ExprCacheStore (Parse *, int, int, int)

SQLITE_PRIVATE void	sqlite3ExprCachePush (Parse *)

SQLITE_PRIVATE void	sqlite3ExprCachePop (Parse *)

SQLITE_PRIVATE void	sqlite3ExprCacheRemove (Parse *, int, int)

SQLITE_PRIVATE void	sqlite3ExprCacheClear (Parse *)

SQLITE_PRIVATE void	sqlite3ExprCacheAffinityChange (Parse *, int, int)

SQLITE_PRIVATE void	sqlite3ExprCode (Parse , Expr , int)

SQLITE_PRIVATE void	sqlite3ExprCodeFactorable (Parse , Expr , int)

SQLITE_PRIVATE void	sqlite3ExprCodeAtInit (Parse , Expr , int, u8)

SQLITE_PRIVATE int	sqlite3ExprCodeTemp (Parse , Expr , int *)

SQLITE_PRIVATE int	sqlite3ExprCodeTarget (Parse , Expr , int)

SQLITE_PRIVATE void	sqlite3ExprCodeAndCache (Parse , Expr , int)

SQLITE_PRIVATE int	sqlite3ExprCodeExprList (Parse , ExprList , int, u8)

SQLITE_PRIVATE void	sqlite3ExprIfTrue (Parse , Expr , int, int)

SQLITE_PRIVATE void	sqlite3ExprIfFalse (Parse , Expr , int, int)

SQLITE_PRIVATE Table *	sqlite3FindTable (sqlite3 , const char , const char *)

SQLITE_PRIVATE Table *	sqlite3LocateTable (Parse , int isView, const char , const char *)

SQLITE_PRIVATE Table *	sqlite3LocateTableItem (Parse , int isView, struct SrcList_item )

SQLITE_PRIVATE Index *	sqlite3FindIndex (sqlite3 , const char , const char *)

SQLITE_PRIVATE void	sqlite3UnlinkAndDeleteTable (sqlite3 , int, const char )

SQLITE_PRIVATE void	sqlite3UnlinkAndDeleteIndex (sqlite3 , int, const char )

SQLITE_PRIVATE void	sqlite3Vacuum (Parse *)

SQLITE_PRIVATE int	sqlite3RunVacuum (char *, sqlite3 )

SQLITE_PRIVATE char *	sqlite3NameFromToken (sqlite3 , Token )

SQLITE_PRIVATE int	sqlite3ExprCompare (Expr , Expr , int)

SQLITE_PRIVATE int	sqlite3ExprListCompare (ExprList , ExprList , int)

SQLITE_PRIVATE int	sqlite3ExprImpliesExpr (Expr , Expr , int)

SQLITE_PRIVATE void	sqlite3ExprAnalyzeAggregates (NameContext , Expr )

SQLITE_PRIVATE void	sqlite3ExprAnalyzeAggList (NameContext , ExprList )

SQLITE_PRIVATE int	sqlite3FunctionUsesThisSrc (Expr , SrcList )

SQLITE_PRIVATE Vdbe *	sqlite3GetVdbe (Parse *)

SQLITE_PRIVATE void	sqlite3PrngSaveState (void)

SQLITE_PRIVATE void	sqlite3PrngRestoreState (void)

SQLITE_PRIVATE void	sqlite3RollbackAll (sqlite3 *, int)

SQLITE_PRIVATE void	sqlite3CodeVerifySchema (Parse *, int)

SQLITE_PRIVATE void	sqlite3CodeVerifyNamedSchema (Parse , const char zDb)

SQLITE_PRIVATE void	sqlite3BeginTransaction (Parse *, int)

SQLITE_PRIVATE void	sqlite3CommitTransaction (Parse *)

SQLITE_PRIVATE void	sqlite3RollbackTransaction (Parse *)

SQLITE_PRIVATE void	sqlite3Savepoint (Parse , int, Token )

SQLITE_PRIVATE void	sqlite3CloseSavepoints (sqlite3 *)

SQLITE_PRIVATE void	sqlite3LeaveMutexAndCloseZombie (sqlite3 *)

SQLITE_PRIVATE int	sqlite3ExprIsConstant (Expr *)

SQLITE_PRIVATE int	sqlite3ExprIsConstantNotJoin (Expr *)

SQLITE_PRIVATE int	sqlite3ExprIsConstantOrFunction (Expr *, u8)

SQLITE_PRIVATE int	sqlite3ExprIsTableConstant (Expr *, int)

SQLITE_PRIVATE int	sqlite3ExprIsInteger (Expr , int )

SQLITE_PRIVATE int	sqlite3ExprCanBeNull (const Expr *)

SQLITE_PRIVATE int	sqlite3ExprNeedsNoAffinityChange (const Expr *, char)

SQLITE_PRIVATE int	sqlite3IsRowid (const char *)

SQLITE_PRIVATE void	sqlite3GenerateRowDelete (Parse , Table , Trigger *, int, int, int, i16, u8, u8, u8)

SQLITE_PRIVATE void	sqlite3GenerateRowIndexDelete (Parse , Table , int, int, int *)

SQLITE_PRIVATE int	sqlite3GenerateIndexKey (Parse , Index , int, int, int, int , Index , int)

SQLITE_PRIVATE void	sqlite3ResolvePartIdxLabel (Parse *, int)

SQLITE_PRIVATE void	sqlite3GenerateConstraintChecks (Parse , Table , int , int, int, int, int, u8, u8, int, int )

SQLITE_PRIVATE void	sqlite3CompleteInsertion (Parse , Table , int, int, int, int *, int, int, int)

SQLITE_PRIVATE int	sqlite3OpenTableAndIndices (Parse , Table , int, int, u8 , int , int *)

SQLITE_PRIVATE void	sqlite3BeginWriteOperation (Parse *, int, int)

SQLITE_PRIVATE void	sqlite3MultiWrite (Parse *)

SQLITE_PRIVATE void	sqlite3MayAbort (Parse *)

SQLITE_PRIVATE void	sqlite3HaltConstraint (Parse , int, int, char , i8, u8)

SQLITE_PRIVATE void	sqlite3UniqueConstraint (Parse , int, Index )

SQLITE_PRIVATE void	sqlite3RowidConstraint (Parse , int, Table )

SQLITE_PRIVATE Expr *	sqlite3ExprDup (sqlite3 , Expr , int)

SQLITE_PRIVATE ExprList *	sqlite3ExprListDup (sqlite3 , ExprList , int)

SQLITE_PRIVATE SrcList *	sqlite3SrcListDup (sqlite3 , SrcList , int)

SQLITE_PRIVATE IdList *	sqlite3IdListDup (sqlite3 , IdList )

SQLITE_PRIVATE Select *	sqlite3SelectDup (sqlite3 , Select , int)

SQLITE_PRIVATE void	sqlite3FuncDefInsert (FuncDefHash , FuncDef )

SQLITE_PRIVATE FuncDef *	sqlite3FindFunction (sqlite3 , const char , int, int, u8, u8)

SQLITE_PRIVATE void	sqlite3RegisterBuiltinFunctions (sqlite3 *)

SQLITE_PRIVATE void	sqlite3RegisterDateTimeFunctions (void)

SQLITE_PRIVATE void	sqlite3RegisterGlobalFunctions (void)

SQLITE_PRIVATE int	sqlite3SafetyCheckOk (sqlite3 *)

SQLITE_PRIVATE int	sqlite3SafetyCheckSickOrOk (sqlite3 *)

SQLITE_PRIVATE void	sqlite3ChangeCookie (Parse *, int)

SQLITE_PRIVATE void	sqlite3MaterializeView (Parse , Table , Expr *, int)

SQLITE_PRIVATE void	sqlite3BeginTrigger (Parse , Token , Token , int, int, IdList , SrcList , Expr , int, int)

SQLITE_PRIVATE void	sqlite3FinishTrigger (Parse , TriggerStep , Token *)

SQLITE_PRIVATE void	sqlite3DropTrigger (Parse , SrcList , int)

SQLITE_PRIVATE void	sqlite3DropTriggerPtr (Parse , Trigger )

SQLITE_PRIVATE Trigger *	sqlite3TriggersExist (Parse , Table , int, ExprList , int pMask)

SQLITE_PRIVATE Trigger *	sqlite3TriggerList (Parse , Table )

SQLITE_PRIVATE void	sqlite3CodeRowTrigger (Parse , Trigger , int, ExprList , int, Table , int, int, int)

SQLITE_PRIVATE void	sqlite3CodeRowTriggerDirect (Parse , Trigger , Table *, int, int, int)

void	sqliteViewTriggers (Parse , Table , Expr , int, ExprList )

SQLITE_PRIVATE void	sqlite3DeleteTriggerStep (sqlite3 , TriggerStep )

SQLITE_PRIVATE TriggerStep *	sqlite3TriggerSelectStep (sqlite3 , Select )

SQLITE_PRIVATE TriggerStep *	sqlite3TriggerInsertStep (sqlite3 , Token , IdList , Select , u8)

SQLITE_PRIVATE TriggerStep *	sqlite3TriggerUpdateStep (sqlite3 , Token , ExprList , Expr , u8)

SQLITE_PRIVATE TriggerStep *	sqlite3TriggerDeleteStep (sqlite3 , Token , Expr *)

SQLITE_PRIVATE void	sqlite3DeleteTrigger (sqlite3 , Trigger )

SQLITE_PRIVATE void	sqlite3UnlinkAndDeleteTrigger (sqlite3 , int, const char )

SQLITE_PRIVATE u32	sqlite3TriggerColmask (Parse , Trigger , ExprList , int, int, Table , int)

SQLITE_PRIVATE int	sqlite3JoinType (Parse , Token , Token , Token )

SQLITE_PRIVATE void	sqlite3CreateForeignKey (Parse , ExprList , Token , ExprList , int)

SQLITE_PRIVATE void	sqlite3DeferForeignKey (Parse *, int)

SQLITE_PRIVATE void	sqlite3AuthRead (Parse , Expr , Schema , SrcList )

SQLITE_PRIVATE int	sqlite3AuthCheck (Parse , int, const char , const char , const char )

SQLITE_PRIVATE void	sqlite3AuthContextPush (Parse , AuthContext , const char *)

SQLITE_PRIVATE void	sqlite3AuthContextPop (AuthContext *)

SQLITE_PRIVATE int	sqlite3AuthReadCol (Parse , const char , const char *, int)

SQLITE_PRIVATE void	sqlite3Attach (Parse , Expr , Expr , Expr )

SQLITE_PRIVATE void	sqlite3Detach (Parse , Expr )

SQLITE_PRIVATE void	sqlite3FixInit (DbFixer , Parse , int, const char , const Token )

SQLITE_PRIVATE int	sqlite3FixSrcList (DbFixer , SrcList )

SQLITE_PRIVATE int	sqlite3FixSelect (DbFixer , Select )

SQLITE_PRIVATE int	sqlite3FixExpr (DbFixer , Expr )

SQLITE_PRIVATE int	sqlite3FixExprList (DbFixer , ExprList )

SQLITE_PRIVATE int	sqlite3FixTriggerStep (DbFixer , TriggerStep )

SQLITE_PRIVATE int	sqlite3AtoF (const char z, double , int, u8)

SQLITE_PRIVATE int	sqlite3GetInt32 (const char , int )

SQLITE_PRIVATE int	sqlite3Atoi (const char *)

SQLITE_PRIVATE int	sqlite3Utf16ByteLen (const void *pData, int nChar)

SQLITE_PRIVATE int	sqlite3Utf8CharLen (const char *pData, int nByte)

SQLITE_PRIVATE u32	sqlite3Utf8Read (const u8 **)

SQLITE_PRIVATE LogEst	sqlite3LogEst (u64)

SQLITE_PRIVATE LogEst	sqlite3LogEstAdd (LogEst, LogEst)

SQLITE_PRIVATE LogEst	sqlite3LogEstFromDouble (double)

SQLITE_PRIVATE u64	sqlite3LogEstToInt (LogEst)

SQLITE_PRIVATE int	sqlite3PutVarint (unsigned char *, u64)

SQLITE_PRIVATE u8	sqlite3GetVarint (const unsigned char , u64 )

SQLITE_PRIVATE u8	sqlite3GetVarint32 (const unsigned char , u32 )

SQLITE_PRIVATE int	sqlite3VarintLen (u64 v)

SQLITE_PRIVATE const char *	sqlite3IndexAffinityStr (Vdbe , Index )

SQLITE_PRIVATE void	sqlite3TableAffinity (Vdbe , Table , int)

SQLITE_PRIVATE char	sqlite3CompareAffinity (Expr *pExpr, char aff2)

SQLITE_PRIVATE int	sqlite3IndexAffinityOk (Expr *pExpr, char idx_affinity)

SQLITE_PRIVATE char	sqlite3ExprAffinity (Expr *pExpr)

SQLITE_PRIVATE int	sqlite3Atoi64 (const char , i64 , int, u8)

SQLITE_PRIVATE int	sqlite3DecOrHexToI64 (const char , i64 )

SQLITE_PRIVATE void	sqlite3ErrorWithMsg (sqlite3 , int, const char ,...)

SQLITE_PRIVATE void	sqlite3Error (sqlite3 *, int)

SQLITE_PRIVATE void *	sqlite3HexToBlob (sqlite3 , const char z, int n)

SQLITE_PRIVATE u8	sqlite3HexToInt (int h)

SQLITE_PRIVATE int	sqlite3TwoPartName (Parse , Token , Token , Token *)

SQLITE_PRIVATE const char *	sqlite3ErrStr (int)

SQLITE_PRIVATE int	sqlite3ReadSchema (Parse *pParse)

SQLITE_PRIVATE CollSeq *	sqlite3FindCollSeq (sqlite3 , u8 enc, const char , int)

SQLITE_PRIVATE CollSeq *	sqlite3LocateCollSeq (Parse pParse, const char zName)

SQLITE_PRIVATE CollSeq *	sqlite3ExprCollSeq (Parse pParse, Expr pExpr)

SQLITE_PRIVATE Expr *	sqlite3ExprAddCollateToken (Parse pParse, Expr , const Token *, int)

SQLITE_PRIVATE Expr *	sqlite3ExprAddCollateString (Parse , Expr , const char *)

SQLITE_PRIVATE Expr *	sqlite3ExprSkipCollate (Expr *)

SQLITE_PRIVATE int	sqlite3CheckCollSeq (Parse , CollSeq )

SQLITE_PRIVATE int	sqlite3CheckObjectName (Parse , const char )

SQLITE_PRIVATE void	sqlite3VdbeSetChanges (sqlite3 *, int)

SQLITE_PRIVATE int	sqlite3AddInt64 (i64 *, i64)

SQLITE_PRIVATE int	sqlite3SubInt64 (i64 *, i64)

SQLITE_PRIVATE int	sqlite3MulInt64 (i64 *, i64)

SQLITE_PRIVATE int	sqlite3AbsInt32 (int)

SQLITE_PRIVATE u8	sqlite3GetBoolean (const char *z, u8)

SQLITE_PRIVATE const void *	sqlite3ValueText (sqlite3_value *, u8)

SQLITE_PRIVATE int	sqlite3ValueBytes (sqlite3_value *, u8)

SQLITE_PRIVATE void	sqlite3ValueSetStr (sqlite3_value , int, const void , u8, void()(void ))

SQLITE_PRIVATE void	sqlite3ValueSetNull (sqlite3_value *)

SQLITE_PRIVATE void	sqlite3ValueFree (sqlite3_value *)

SQLITE_PRIVATE sqlite3_value *	sqlite3ValueNew (sqlite3 *)

SQLITE_PRIVATE char *	sqlite3Utf16to8 (sqlite3 , const void , int, u8)

SQLITE_PRIVATE int	sqlite3ValueFromExpr (sqlite3 , Expr , u8, u8, sqlite3_value **)

SQLITE_PRIVATE void	sqlite3ValueApplyAffinity (sqlite3_value *, u8, u8)

SQLITE_PRIVATE void	sqlite3RootPageMoved (sqlite3 *, int, int, int)

SQLITE_PRIVATE void	sqlite3Reindex (Parse , Token , Token *)

SQLITE_PRIVATE void	sqlite3AlterFunctions (void)

SQLITE_PRIVATE void	sqlite3AlterRenameTable (Parse , SrcList , Token *)

SQLITE_PRIVATE int	sqlite3GetToken (const unsigned char , int )

SQLITE_PRIVATE void	sqlite3NestedParse (Parse , const char ,...)

SQLITE_PRIVATE void	sqlite3ExpirePreparedStatements (sqlite3 *)

SQLITE_PRIVATE int	sqlite3CodeSubselect (Parse , Expr , int, int)

SQLITE_PRIVATE void	sqlite3SelectPrep (Parse , Select , NameContext *)

SQLITE_PRIVATE int	sqlite3MatchSpanName (const char , const char , const char , const char )

SQLITE_PRIVATE int	sqlite3ResolveExprNames (NameContext , Expr )

SQLITE_PRIVATE void	sqlite3ResolveSelectNames (Parse , Select , NameContext *)

SQLITE_PRIVATE void	sqlite3ResolveSelfReference (Parse , Table , int, Expr , ExprList )

SQLITE_PRIVATE int	sqlite3ResolveOrderGroupBy (Parse , Select , ExprList , const char )

SQLITE_PRIVATE void	sqlite3ColumnDefault (Vdbe , Table , int, int)

SQLITE_PRIVATE void	sqlite3AlterFinishAddColumn (Parse , Token )

SQLITE_PRIVATE void	sqlite3AlterBeginAddColumn (Parse , SrcList )

SQLITE_PRIVATE CollSeq *	sqlite3GetCollSeq (Parse , u8, CollSeq , const char *)

SQLITE_PRIVATE char	sqlite3AffinityType (const char , u8 )

SQLITE_PRIVATE void	sqlite3Analyze (Parse , Token , Token *)

SQLITE_PRIVATE int	sqlite3InvokeBusyHandler (BusyHandler *)

SQLITE_PRIVATE int	sqlite3FindDb (sqlite3 , Token )

SQLITE_PRIVATE int	sqlite3FindDbName (sqlite3 , const char )

SQLITE_PRIVATE int	sqlite3AnalysisLoad (sqlite3 *, int iDB)

SQLITE_PRIVATE void	sqlite3DeleteIndexSamples (sqlite3 , Index )

SQLITE_PRIVATE void	sqlite3DefaultRowEst (Index *)

SQLITE_PRIVATE void	sqlite3RegisterLikeFunctions (sqlite3 *, int)

SQLITE_PRIVATE int	sqlite3IsLikeFunction (sqlite3 , Expr , int , char )

SQLITE_PRIVATE void	sqlite3MinimumFileFormat (Parse *, int, int)

SQLITE_PRIVATE void	sqlite3SchemaClear (void *)

SQLITE_PRIVATE Schema *	sqlite3SchemaGet (sqlite3 , Btree )

SQLITE_PRIVATE int	sqlite3SchemaToIndex (sqlite3 db, Schema )

SQLITE_PRIVATE KeyInfo *	sqlite3KeyInfoAlloc (sqlite3 *, int, int)

SQLITE_PRIVATE void	sqlite3KeyInfoUnref (KeyInfo *)

SQLITE_PRIVATE KeyInfo *	sqlite3KeyInfoRef (KeyInfo *)

SQLITE_PRIVATE KeyInfo *	sqlite3KeyInfoOfIndex (Parse , Index )

SQLITE_PRIVATE int	sqlite3CreateFunc (sqlite3 , const char , int, int, void , void()(sqlite3_context , int, sqlite3_value ), void()(sqlite3_context , int, sqlite3_value ), void()(sqlite3_context ), FuncDestructor pDestructor)

SQLITE_PRIVATE int	sqlite3ApiExit (sqlite3 *db, int)

SQLITE_PRIVATE int	sqlite3OpenTempDatabase (Parse *)

SQLITE_PRIVATE void	sqlite3StrAccumInit (StrAccum , char , int, int)

SQLITE_PRIVATE void	sqlite3StrAccumAppend (StrAccum , const char , int)

SQLITE_PRIVATE void	sqlite3StrAccumAppendAll (StrAccum , const char )

SQLITE_PRIVATE void	sqlite3AppendChar (StrAccum *, int, char)

SQLITE_PRIVATE char *	sqlite3StrAccumFinish (StrAccum *)

SQLITE_PRIVATE void	sqlite3StrAccumReset (StrAccum *)

SQLITE_PRIVATE void	sqlite3SelectDestInit (SelectDest *, int, int)

SQLITE_PRIVATE Expr *	sqlite3CreateColumnExpr (sqlite3 , SrcList , int, int)

SQLITE_PRIVATE void	sqlite3BackupRestart (sqlite3_backup *)

SQLITE_PRIVATE void	sqlite3BackupUpdate (sqlite3_backup , Pgno, const u8 )

SQLITE_PRIVATE void *	sqlite3ParserAlloc (void ()(u64))

SQLITE_PRIVATE void	sqlite3ParserFree (void , void()(void *))

SQLITE_PRIVATE void	sqlite3Parser (void , int, Token, Parse )

SQLITE_PRIVATE void	sqlite3AutoLoadExtensions (sqlite3 *)

SQLITE_PRIVATE void	sqlite3CloseExtensions (sqlite3 *)

SQLITE_PRIVATE void	sqlite3TableLock (Parse , int, int, u8, const char )

SQLITE_PRIVATE void	sqlite3VtabClear (sqlite3 db, Table )

SQLITE_PRIVATE void	sqlite3VtabDisconnect (sqlite3 db, Table p)

SQLITE_PRIVATE int	sqlite3VtabSync (sqlite3 db, Vdbe )

SQLITE_PRIVATE int	sqlite3VtabRollback (sqlite3 *db)

SQLITE_PRIVATE int	sqlite3VtabCommit (sqlite3 *db)

SQLITE_PRIVATE void	sqlite3VtabLock (VTable *)

SQLITE_PRIVATE void	sqlite3VtabUnlock (VTable *)

SQLITE_PRIVATE void	sqlite3VtabUnlockList (sqlite3 *)

SQLITE_PRIVATE int	sqlite3VtabSavepoint (sqlite3 *, int, int)

SQLITE_PRIVATE void	sqlite3VtabImportErrmsg (Vdbe , sqlite3_vtab )

SQLITE_PRIVATE VTable *	sqlite3GetVTable (sqlite3 , Table )

SQLITE_PRIVATE void	sqlite3VtabMakeWritable (Parse , Table )

SQLITE_PRIVATE void	sqlite3VtabBeginParse (Parse , Token , Token , Token , int)

SQLITE_PRIVATE void	sqlite3VtabFinishParse (Parse , Token )

SQLITE_PRIVATE void	sqlite3VtabArgInit (Parse *)

SQLITE_PRIVATE void	sqlite3VtabArgExtend (Parse , Token )

SQLITE_PRIVATE int	sqlite3VtabCallCreate (sqlite3 , int, const char , char **)

SQLITE_PRIVATE int	sqlite3VtabCallConnect (Parse , Table )

SQLITE_PRIVATE int	sqlite3VtabCallDestroy (sqlite3 , int, const char )

SQLITE_PRIVATE int	sqlite3VtabBegin (sqlite3 , VTable )

SQLITE_PRIVATE FuncDef *	sqlite3VtabOverloadFunction (sqlite3 , FuncDef , int nArg, Expr *)

SQLITE_PRIVATE void	sqlite3InvalidFunction (sqlite3_context , int, sqlite3_value *)

SQLITE_PRIVATE sqlite3_int64	sqlite3StmtCurrentTime (sqlite3_context *)

SQLITE_PRIVATE int	sqlite3VdbeParameterIndex (Vdbe , const char , int)

SQLITE_PRIVATE int	sqlite3TransferBindings (sqlite3_stmt , sqlite3_stmt )

SQLITE_PRIVATE void	sqlite3ParserReset (Parse *)

SQLITE_PRIVATE int	sqlite3Reprepare (Vdbe *)

SQLITE_PRIVATE void	sqlite3ExprListCheckLength (Parse , ExprList , const char *)

SQLITE_PRIVATE CollSeq *	sqlite3BinaryCompareCollSeq (Parse , Expr , Expr *)

SQLITE_PRIVATE int	sqlite3TempInMemory (const sqlite3 *)

SQLITE_PRIVATE const char *	sqlite3JournalModename (int)

SQLITE_PRIVATE int	sqlite3Checkpoint (sqlite3 , int, int, int , int *)

SQLITE_PRIVATE int	sqlite3WalDefaultHook (void , sqlite3 , const char *, int)

SQLITE_PRIVATE With *	sqlite3WithAdd (Parse , With , Token , ExprList , Select *)

SQLITE_PRIVATE void	sqlite3WithDelete (sqlite3 , With )

SQLITE_PRIVATE void	sqlite3WithPush (Parse , With , u8)

SQLITE_PRIVATE void	sqlite3FkCheck (Parse , Table , int, int, int *, int)

SQLITE_PRIVATE void	sqlite3FkDropTable (Parse , SrcList , Table *)

SQLITE_PRIVATE void	sqlite3FkActions (Parse , Table , ExprList , int, int , int)

SQLITE_PRIVATE int	sqlite3FkRequired (Parse , Table , int *, int)

SQLITE_PRIVATE u32	sqlite3FkOldmask (Parse , Table )

SQLITE_PRIVATE FKey *	sqlite3FkReferences (Table *)

SQLITE_PRIVATE void	sqlite3FkDelete (sqlite3 , Table )

SQLITE_PRIVATE int	sqlite3FkLocateIndex (Parse , Table , FKey , Index , int *)

SQLITE_PRIVATE void	sqlite3BeginBenignMalloc (void)

SQLITE_PRIVATE void	sqlite3EndBenignMalloc (void)

SQLITE_PRIVATE int	sqlite3FindInIndex (Parse , Expr , u32, int *)

SQLITE_PRIVATE void	sqlite3MemJournalOpen (sqlite3_file *)

SQLITE_PRIVATE int	sqlite3MemJournalSize (void)

SQLITE_PRIVATE int	sqlite3IsMemJournal (sqlite3_file *)

SQLITE_PRIVATE void	sqlite3ExprSetHeightAndFlags (Parse pParse, Expr p)

SQLITE_PRIVATE int	sqlite3SelectExprHeight (Select *)

SQLITE_PRIVATE int	sqlite3ExprCheckHeight (Parse *, int)

SQLITE_PRIVATE u32	sqlite3Get4byte (const u8 *)

SQLITE_PRIVATE void	sqlite3Put4byte (u8 *, u32)

SQLITE_PRIVATE int	sqlite3ThreadCreate (SQLiteThread *, void ()(void ), void *)

SQLITE_PRIVATE int	sqlite3ThreadJoin (SQLiteThread , void *)

SQLITE_PRIVATE void	sqlite3VdbeFreeCursor (Vdbe , VdbeCursor )

void	sqliteVdbePopStack (Vdbe *, int)

SQLITE_PRIVATE int	sqlite3VdbeCursorMoveto (VdbeCursor *)

SQLITE_PRIVATE int	sqlite3VdbeCursorRestore (VdbeCursor *)

SQLITE_PRIVATE u32	sqlite3VdbeSerialTypeLen (u32)

SQLITE_PRIVATE u32	sqlite3VdbeSerialType (Mem *, int)

SQLITE_PRIVATE u32	sqlite3VdbeSerialPut (unsigned char , Mem , u32)

SQLITE_PRIVATE u32	sqlite3VdbeSerialGet (const unsigned char , u32, Mem )

SQLITE_PRIVATE void	sqlite3VdbeDeleteAuxData (Vdbe *, int, int)

int	sqlite2BtreeKeyCompare (BtCursor , const void , int, int, int *)

SQLITE_PRIVATE int	sqlite3VdbeIdxKeyCompare (sqlite3 , VdbeCursor , UnpackedRecord , int )

SQLITE_PRIVATE int	sqlite3VdbeIdxRowid (sqlite3 , BtCursor , i64 *)

SQLITE_PRIVATE int	sqlite3VdbeExec (Vdbe *)

SQLITE_PRIVATE int	sqlite3VdbeList (Vdbe *)

SQLITE_PRIVATE int	sqlite3VdbeHalt (Vdbe *)

SQLITE_PRIVATE int	sqlite3VdbeChangeEncoding (Mem *, int)

SQLITE_PRIVATE int	sqlite3VdbeMemTooBig (Mem *)

SQLITE_PRIVATE int	sqlite3VdbeMemCopy (Mem , const Mem )

SQLITE_PRIVATE void	sqlite3VdbeMemShallowCopy (Mem , const Mem , int)

SQLITE_PRIVATE void	sqlite3VdbeMemMove (Mem , Mem )

SQLITE_PRIVATE int	sqlite3VdbeMemNulTerminate (Mem *)

SQLITE_PRIVATE int	sqlite3VdbeMemSetStr (Mem , const char , int, u8, void()(void ))

SQLITE_PRIVATE void	sqlite3VdbeMemSetInt64 (Mem *, i64)

SQLITE_PRIVATE void	sqlite3VdbeMemSetDouble (Mem *, double)

SQLITE_PRIVATE void	sqlite3VdbeMemInit (Mem , sqlite3 , u16)

SQLITE_PRIVATE void	sqlite3VdbeMemSetNull (Mem *)

SQLITE_PRIVATE void	sqlite3VdbeMemSetZeroBlob (Mem *, int)

SQLITE_PRIVATE void	sqlite3VdbeMemSetRowSet (Mem *)

SQLITE_PRIVATE int	sqlite3VdbeMemMakeWriteable (Mem *)

SQLITE_PRIVATE int	sqlite3VdbeMemStringify (Mem *, u8, u8)

SQLITE_PRIVATE i64	sqlite3VdbeIntValue (Mem *)

SQLITE_PRIVATE int	sqlite3VdbeMemIntegerify (Mem *)

SQLITE_PRIVATE double	sqlite3VdbeRealValue (Mem *)

SQLITE_PRIVATE void	sqlite3VdbeIntegerAffinity (Mem *)

SQLITE_PRIVATE int	sqlite3VdbeMemRealify (Mem *)

SQLITE_PRIVATE int	sqlite3VdbeMemNumerify (Mem *)

SQLITE_PRIVATE void	sqlite3VdbeMemCast (Mem *, u8, u8)

SQLITE_PRIVATE int	sqlite3VdbeMemFromBtree (BtCursor , u32, u32, int, Mem )

SQLITE_PRIVATE void	sqlite3VdbeMemRelease (Mem *p)

SQLITE_PRIVATE int	sqlite3VdbeMemFinalize (Mem , FuncDef )

SQLITE_PRIVATE const char *	sqlite3OpcodeName (int)

SQLITE_PRIVATE int	sqlite3VdbeMemGrow (Mem *pMem, int n, int preserve)

SQLITE_PRIVATE int	sqlite3VdbeMemClearAndResize (Mem *pMem, int n)

SQLITE_PRIVATE int	sqlite3VdbeCloseStatement (Vdbe *, int)

SQLITE_PRIVATE void	sqlite3VdbeFrameDelete (VdbeFrame *)

SQLITE_PRIVATE int	sqlite3VdbeFrameRestore (VdbeFrame *)

SQLITE_PRIVATE int	sqlite3VdbeTransferError (Vdbe *p)

SQLITE_PRIVATE int	sqlite3VdbeSorterInit (sqlite3 , int, VdbeCursor )

SQLITE_PRIVATE void	sqlite3VdbeSorterReset (sqlite3 , VdbeSorter )

SQLITE_PRIVATE void	sqlite3VdbeSorterClose (sqlite3 , VdbeCursor )

SQLITE_PRIVATE int	sqlite3VdbeSorterRowkey (const VdbeCursor , Mem )

SQLITE_PRIVATE int	sqlite3VdbeSorterNext (sqlite3 , const VdbeCursor , int *)

SQLITE_PRIVATE int	sqlite3VdbeSorterRewind (const VdbeCursor , int )

SQLITE_PRIVATE int	sqlite3VdbeSorterWrite (const VdbeCursor , Mem )

SQLITE_PRIVATE int	sqlite3VdbeSorterCompare (const VdbeCursor , Mem , int, int *)

SQLITE_PRIVATE void	sqlite3VdbeEnter (Vdbe *)

SQLITE_PRIVATE void	sqlite3VdbeLeave (Vdbe *)

SQLITE_PRIVATE int	sqlite3VdbeCheckFk (Vdbe *, int)

SQLITE_PRIVATE int	sqlite3VdbeMemTranslate (Mem *, u8)

SQLITE_PRIVATE int	sqlite3VdbeMemHandleBom (Mem *pMem)

SQLITE_PRIVATE int	sqlite3VdbeMemExpandBlob (Mem *)

SQLITE_API int SQLITE_STDCALL	sqlite3_memory_alarm (void(xCallback)(void pArg, sqlite3_int64 used, int N), void *pArg, sqlite3_int64 iThreshold)

SQLITE_PRIVATE int	sqlite3ThreadCreate (SQLiteThread *ppThread, void (xTask)(void ), void *pIn)

SQLITE_PRIVATE u32	sqlite3Utf8Read (const unsigned char **pz)

SQLITE_PRIVATE void	sqlite3Put4byte (unsigned char *p, u32 v)

	IOMETHODS (posixIoFinder, posixIoMethods, IOMETHODS(3, unixClose, unixLock, unixUnlock, unixCheckReservedLock, unixShmMap)

SQLITE_PRIVATE int	sqlite3WalOpen (sqlite3_vfs , sqlite3_file , const char , int, i64, Wal *)

SQLITE_PRIVATE int	sqlite3WalClose (Wal pWal, int sync_flags, int, u8 )

SQLITE_PRIVATE void	sqlite3WalLimit (Wal *, i64)

SQLITE_PRIVATE int	sqlite3WalBeginReadTransaction (Wal pWal, int )

SQLITE_PRIVATE void	sqlite3WalEndReadTransaction (Wal *pWal)

SQLITE_PRIVATE int	sqlite3WalFindFrame (Wal , Pgno, u32 )

SQLITE_PRIVATE int	sqlite3WalReadFrame (Wal , u32, int, u8 )

SQLITE_PRIVATE Pgno	sqlite3WalDbsize (Wal *pWal)

SQLITE_PRIVATE int	sqlite3WalBeginWriteTransaction (Wal *pWal)

SQLITE_PRIVATE int	sqlite3WalEndWriteTransaction (Wal *pWal)

SQLITE_PRIVATE int	sqlite3WalUndo (Wal pWal, int(xUndo)(void , Pgno), void pUndoCtx)

SQLITE_PRIVATE void	sqlite3WalSavepoint (Wal pWal, u32 aWalData)

SQLITE_PRIVATE int	sqlite3WalSavepointUndo (Wal pWal, u32 aWalData)

SQLITE_PRIVATE int	sqlite3WalFrames (Wal pWal, int, PgHdr , Pgno, int, int)

SQLITE_PRIVATE int	sqlite3WalCheckpoint (Wal pWal, int eMode, int(xBusy)(void ), void pBusyArg, int sync_flags, int nBuf, u8 zBuf, int pnLog, int *pnCkpt)

SQLITE_PRIVATE int	sqlite3WalCallback (Wal *pWal)

SQLITE_PRIVATE int	sqlite3WalExclusiveMode (Wal *pWal, int op)

SQLITE_PRIVATE int	sqlite3WalHeapMemory (Wal *pWal)

SQLITE_PRIVATE int	sqlite3PagerWrite (PgHdr *pPg)

SQLITE_PRIVATE void	sqlite3PagerDontWrite (PgHdr *pPg)

SQLITE_PRIVATE u32	sqlite3VdbeSerialPut (u8 buf, Mem pMem, u32 serial_type)

SQLITE_PRIVATE void *	sqlite3ParserAlloc (void (mallocProc)(u64))

SQLITE_PRIVATE void	sqlite3Parser (void *yyp, int yymajor, sqlite3ParserTOKENTYPE yyminorsqlite3ParserARG_PDECL)

Variables
SQLITE_API const char	sqlite3_version [] = SQLITE_VERSION

SQLITE_API char *	sqlite3_temp_directory = 0

SQLITE_API char *	sqlite3_data_directory = 0

SQLITE_PRIVATE const int	sqlite3one = 1

SQLITE_PRIVATE void(*)(void)	sqlite3OsDlSym (sqlite3_vfs , void , const char *)

SQLITE_PRIVATE const unsigned char	sqlite3UpperToLower []

SQLITE_PRIVATE const unsigned char	sqlite3CtypeMap [256]

SQLITE_PRIVATE SQLITE_WSD struct Sqlite3Config	sqlite3Config

SQLITE_PRIVATE SQLITE_WSD FuncDefHash	sqlite3GlobalFunctions

SQLITE_PRIVATE const Token	sqlite3IntTokens []

SQLITE_PRIVATE int	sqlite3PendingByte = 0x40000000

SQLITE_PRIVATE const unsigned char	sqlite3OpcodeProperty [] = OPFLG_INITIALIZER

Macro Definition Documentation

#define _BTREE_H_

Definition at line 9333 of file sqlite3.c.

#define _FILE_OFFSET_BITS 64

Definition at line 156 of file sqlite3.c.

#define _FTSINT_H

Definition at line 132398 of file sqlite3.c.

#define _LARGE_FILE 1

Definition at line 154 of file sqlite3.c.

#define _LARGEFILE_SOURCE 1

Definition at line 158 of file sqlite3.c.

#define _MSVC_H_

Definition at line 66 of file sqlite3.c.

#define _OS_COMMON_H_

Definition at line 25548 of file sqlite3.c.

#define _OS_SETUP_H_

Definition at line 10524 of file sqlite3.c.

#define _PAGER_H_

Definition at line 10106 of file sqlite3.c.

#define _SQLITE3_H_

Definition at line 241 of file sqlite3.c.

#define _SQLITE3EXT_H_

Definition at line 101884 of file sqlite3.c.

#define _SQLITE3RTREE_H_

Definition at line 7938 of file sqlite3.c.

#define _SQLITE_HASH_H_

Definition at line 8546 of file sqlite3.c.

#define _SQLITE_OS_C_ 1

Definition at line 16480 of file sqlite3.c.

#define _SQLITE_OS_H_

Definition at line 10500 of file sqlite3.c.

#define _SQLITE_VDBE_H_

Definition at line 9614 of file sqlite3.c.

#define _SQLITEINT_H_

Definition at line 41 of file sqlite3.c.

#define _VDBEINT_H_

Definition at line 14518 of file sqlite3.c.

#define _WAL_H_

Definition at line 41565 of file sqlite3.c.

#define _XOPEN_SOURCE 600

Definition at line 8412 of file sqlite3.c.

#define ADDR ( X ) (-1-(X))

Definition at line 9749 of file sqlite3.c.

#define addScanStatus	(	a,
		b,
		c,
		d
	)	((void)d)

Definition at line 119392 of file sqlite3.c.

#define AGGREGATE	(	zName,
		nArg,
		arg,
		nc,
		xStep,
		xFinal
	)

Value:

{nArg, SQLITE_UTF8|(nc*SQLITE_FUNC_NEEDCOLL), \

SQLITE_INT_TO_PTR(arg), 0, 0, xStep,xFinal,#zName,0,0}

SQLITE_UTF8

#define SQLITE_UTF8

Definition: sqlite3.c:4463

SQLITE_INT_TO_PTR

#define SQLITE_INT_TO_PTR(X)

Definition: sqlite3.c:8306

SQLITE_FUNC_NEEDCOLL

#define SQLITE_FUNC_NEEDCOLL

Definition: sqlite3.c:11244

Definition at line 11296 of file sqlite3.c.

#define AGGREGATE2	(	zName,
		nArg,
		arg,
		nc,
		xStep,
		xFinal,
		extraFlags
	)

Value:

{nArg, SQLITE_UTF8|(nc*SQLITE_FUNC_NEEDCOLL)|extraFlags, \

SQLITE_INT_TO_PTR(arg), 0, 0, xStep,xFinal,#zName,0,0}

SQLITE_UTF8

#define SQLITE_UTF8

Definition: sqlite3.c:4463

SQLITE_INT_TO_PTR

#define SQLITE_INT_TO_PTR(X)

Definition: sqlite3.c:8306

SQLITE_FUNC_NEEDCOLL

#define SQLITE_FUNC_NEEDCOLL

Definition: sqlite3.c:11244

Definition at line 11299 of file sqlite3.c.

#define ALWAYS ( X ) (X)

Definition at line 8508 of file sqlite3.c.

#define ApplyCostMultiplier	(	C,
		T
	)

Definition at line 120853 of file sqlite3.c.

#define ArraySize ( X ) ((int)(sizeof(X)/sizeof(X[0])))

Definition at line 9198 of file sqlite3.c.

#define assertCellInfo ( x )

Definition at line 57055 of file sqlite3.c.

#define assertParentIndex	(	x,
		y,
		z
	)

Definition at line 57630 of file sqlite3.c.

#define assertTruncateConstraint ( pPager )

Definition at line 45487 of file sqlite3.c.

#define BITVEC_HASH ( X ) (((X)*1)%BITVEC_NINT)

Definition at line 38944 of file sqlite3.c.

#define BITVEC_MXHASH (BITVEC_NINT/2)

Definition at line 38939 of file sqlite3.c.

#define BITVEC_NBIT (BITVEC_NELEM*BITVEC_SZELEM)

Definition at line 38933 of file sqlite3.c.

#define BITVEC_NELEM (BITVEC_USIZE/sizeof(BITVEC_TELEM))

Definition at line 38931 of file sqlite3.c.

#define BITVEC_NINT (BITVEC_USIZE/sizeof(u32))

Definition at line 38936 of file sqlite3.c.

#define BITVEC_NPTR (BITVEC_USIZE/sizeof(Bitvec *))

Definition at line 38946 of file sqlite3.c.

#define BITVEC_SZ 512

Definition at line 38917 of file sqlite3.c.

#define BITVEC_SZELEM 8

Definition at line 38929 of file sqlite3.c.

#define BITVEC_TELEM u8

Definition at line 38927 of file sqlite3.c.

#define BITVEC_USIZE (((BITVEC_SZ-(3*sizeof(u32)))/sizeof(Bitvec*))*sizeof(Bitvec*))

Definition at line 38921 of file sqlite3.c.

#define BMS ((int)(sizeof(Bitmask)*8))

Definition at line 12116 of file sqlite3.c.

#define BTALLOC_ANY 0 /* Allocate any page */

Definition at line 53131 of file sqlite3.c.

#define BTALLOC_EXACT 1 /* Allocate exact page if possible */

Definition at line 53132 of file sqlite3.c.

#define BTALLOC_LE 2 /* Allocate any page <= the parameter */

Definition at line 53133 of file sqlite3.c.

#define BTCF_AtLast 0x08 /* Cursor is pointing ot the last entry */

Definition at line 52642 of file sqlite3.c.

#define BTCF_Incrblob 0x10 /* True if an incremental I/O handle */

Definition at line 52643 of file sqlite3.c.

#define BTCF_ValidNKey 0x02 /* True if info.nKey is valid */

Definition at line 52640 of file sqlite3.c.

#define BTCF_ValidOvfl 0x04 /* True if aOverflow is valid */

Definition at line 52641 of file sqlite3.c.

#define BTCF_WriteFlag 0x01 /* True if a write cursor */

Definition at line 52639 of file sqlite3.c.

#define BTCURSOR_MAX_DEPTH 20

Definition at line 52594 of file sqlite3.c.

#define BTREE_APPLICATION_ID 8

Definition at line 9465 of file sqlite3.c.

#define BTREE_AUTOVACUUM_FULL 1 /* Do full auto-vacuum */

Definition at line 9349 of file sqlite3.c.

#define BTREE_AUTOVACUUM_INCR 2 /* Incremental vacuum */

Definition at line 9350 of file sqlite3.c.

#define BTREE_AUTOVACUUM_NONE 0 /* Do not do auto-vacuum */

Definition at line 9348 of file sqlite3.c.

#define BTREE_BLOBKEY 2 /* Table has keys only - no data */

Definition at line 9428 of file sqlite3.c.

#define BTREE_BULKLOAD 0x00000001 /* Used to full index in sorted order */

Definition at line 9481 of file sqlite3.c.

#define BTREE_DATA_VERSION 15 /* A virtual meta-value */

Definition at line 9466 of file sqlite3.c.

#define BTREE_DEFAULT_CACHE_SIZE 3

Definition at line 9460 of file sqlite3.c.

#define BTREE_FILE_FORMAT 2

Definition at line 9459 of file sqlite3.c.

#define BTREE_FREE_PAGE_COUNT 0

Definition at line 9457 of file sqlite3.c.

#define BTREE_INCR_VACUUM 7

Definition at line 9464 of file sqlite3.c.

#define BTREE_INTKEY 1 /* Table has only 64-bit signed integer keys */

Definition at line 9427 of file sqlite3.c.

#define BTREE_LARGEST_ROOT_PAGE 4

Definition at line 9461 of file sqlite3.c.

#define BTREE_MEMORY 2 /* This is an in-memory DB */

Definition at line 9376 of file sqlite3.c.

#define BTREE_OMIT_JOURNAL 1 /* Do not create or use a rollback journal */

Definition at line 9375 of file sqlite3.c.

#define BTREE_SCHEMA_VERSION 1

Definition at line 9458 of file sqlite3.c.

#define BTREE_SEEK_EQ 0x00000002 /* EQ seeks only - no range seeks */

Definition at line 9482 of file sqlite3.c.

#define BTREE_SINGLE 4 /* The file contains at most 1 b-tree */

Definition at line 9377 of file sqlite3.c.

#define BTREE_TEXT_ENCODING 5

Definition at line 9462 of file sqlite3.c.

#define BTREE_UNORDERED 8 /* Use of a hash implementation is OK */

Definition at line 9378 of file sqlite3.c.

#define BTREE_USER_VERSION 6

Definition at line 9463 of file sqlite3.c.

#define btreeIntegrity ( p )

Value:

assert( p->pBt->inTransaction!=TRANS_NONE || p->pBt->nTransaction==0 ); \

assert( p->pBt->inTransaction>=p->inTrans );

TRANS_NONE

#define TRANS_NONE

Definition: sqlite3.c:52482

Definition at line 52745 of file sqlite3.c.

#define BTS_EXCLUSIVE 0x0020 /* pWriter has an exclusive lock */

Definition at line 52567 of file sqlite3.c.

#define BTS_INITIALLY_EMPTY 0x0008 /* Database was empty at trans start */

Definition at line 52565 of file sqlite3.c.

#define BTS_NO_WAL 0x0010 /* Do not open write-ahead-log files */

Definition at line 52566 of file sqlite3.c.

#define BTS_PAGESIZE_FIXED 0x0002 /* Page size can no longer be changed */

Definition at line 52563 of file sqlite3.c.

#define BTS_PENDING 0x0040 /* Waiting for read-locks to clear */

Definition at line 52568 of file sqlite3.c.

#define BTS_READ_ONLY 0x0001 /* Underlying file is readonly */

Definition at line 52562 of file sqlite3.c.

#define BTS_SECURE_DELETE 0x0004 /* PRAGMA secure_delete is enabled */

Definition at line 52564 of file sqlite3.c.

#define BYTESWAP32 ( x )

Value:

( \
    (((x)&0x000000FF)<<24) + (((x)&0x0000FF00)<<8)  \
  + (((x)&0x00FF0000)>>8)  + (((x)&0xFF000000)>>24) \
)

Definition at line 49513 of file sqlite3.c.

#define CACHE_STALE 0

Definition at line 14656 of file sqlite3.c.

#define charMap ( X ) sqlite3UpperToLower[(unsigned char)X]

Definition at line 126842 of file sqlite3.c.

#define CHECK_PAGE ( x )

Definition at line 42874 of file sqlite3.c.

#define checkActiveVdbeCnt ( x )

Definition at line 67027 of file sqlite3.c.

#define CLEARBIT	(	V,
		I
	)	V[I>>3] &= ~(1<<(I&7))

Definition at line 39177 of file sqlite3.c.

#define CODEC1	(	P,
		D,
		N,
		X,
		E
	)	/* NO-OP */

Definition at line 42082 of file sqlite3.c.

#define CODEC2	(	P,
		D,
		N,
		X,
		E,
		O
	)	O=(char*)D

Definition at line 42083 of file sqlite3.c.

#define COLFLAG_HIDDEN 0x0002 /* A hidden column in a virtual table */

Definition at line 11356 of file sqlite3.c.

#define COLFLAG_PRIMKEY 0x0001 /* Column is part of the primary key */

Definition at line 11355 of file sqlite3.c.

#define COLNAME_COLUMN 4

Definition at line 9732 of file sqlite3.c.

#define COLNAME_DATABASE 2

Definition at line 9730 of file sqlite3.c.

#define COLNAME_DECLTYPE 1

Definition at line 9729 of file sqlite3.c.

#define COLNAME_N 2 /* Store the name and decltype */

Definition at line 9739 of file sqlite3.c.

#define COLNAME_NAME 0

Definition at line 9728 of file sqlite3.c.

#define COLNAME_TABLE 3

Definition at line 9731 of file sqlite3.c.

#define COLUMN_MASK ( x ) (((x)>31) ? 0xffffffff : ((u32)1<<(x)))

Definition at line 99280 of file sqlite3.c.

#define columnType	(	A,
		B,
		C,
		D,
		E,
		F
	)	columnTypeImpl(A,B,F)

Definition at line 107797 of file sqlite3.c.

#define ConstFactorOk ( P ) ((P)->okConstFactor)

Definition at line 11182 of file sqlite3.c.

#define CORRUPT_DB (sqlite3Config.neverCorrupt==0)

Definition at line 12848 of file sqlite3.c.

#define CTIMEOPT_VAL ( opt ) CTIMEOPT_VAL_(opt)

#define CTIMEOPT_VAL_ ( opt ) #opt

#define CURSOR_FAULT 4

Definition at line 52679 of file sqlite3.c.

#define CURSOR_INVALID 0

Definition at line 52675 of file sqlite3.c.

#define CURSOR_REQUIRESEEK 3

Definition at line 52678 of file sqlite3.c.

#define CURSOR_SKIPNEXT 2

Definition at line 52677 of file sqlite3.c.

#define CURSOR_VALID 1

Definition at line 52676 of file sqlite3.c.

#define DB_Empty 0x0004 /* The file is empty (length 0 bytes) */

Definition at line 10896 of file sqlite3.c.

#define DB_SchemaLoaded 0x0001 /* The schema has been loaded */

Definition at line 10894 of file sqlite3.c.

#define DB_UnresetViews 0x0002 /* Some views have defined column names */

Definition at line 10895 of file sqlite3.c.

#define DbClearProperty	(	D,
		I,
		P
	)	(D)->aDb[I].pSchema->schemaFlags&=~(P)

Definition at line 10882 of file sqlite3.c.

#define DbHasAnyProperty	(	D,
		I,
		P
	)	(((D)->aDb[I].pSchema->schemaFlags&(P))!=0)

Definition at line 10880 of file sqlite3.c.

#define DbHasProperty	(	D,
		I,
		P
	)	(((D)->aDb[I].pSchema->schemaFlags&(P))==(P))

Definition at line 10879 of file sqlite3.c.

#define DbMaskAllZero ( M ) (M)==0

Definition at line 12479 of file sqlite3.c.

#define DbMaskNonZero ( M ) (M)!=0

Definition at line 12480 of file sqlite3.c.

#define DbMaskSet	(	M,
		I
	)	(M)\|=(((yDbMask)1)<<(I))

Definition at line 12478 of file sqlite3.c.

#define DbMaskTest	(	M,
		I
	)	(((M)&(((yDbMask)1)<<(I)))!=0)

Definition at line 12476 of file sqlite3.c.

#define DbMaskZero ( M ) (M)=0

Definition at line 12477 of file sqlite3.c.

#define DbSetProperty	(	D,
		I,
		P
	)	(D)->aDb[I].pSchema->schemaFlags\|=(P)

Definition at line 10881 of file sqlite3.c.

#define Deephemeralize ( P )

Value:

if( ((P)->flags&MEM_Ephem)!=0 \

&& sqlite3VdbeMemMakeWriteable(P) ){ goto no_mem;}

MEM_Ephem

#define MEM_Ephem

Definition: sqlite3.c:14721

sqlite3VdbeMemMakeWriteable

SQLITE_PRIVATE int sqlite3VdbeMemMakeWriteable(Mem *)

Definition: sqlite3.c:63308

Definition at line 70938 of file sqlite3.c.

#define DIRECT_MODE 0

#define disable_simulated_io_errors ( )

Definition at line 45370 of file sqlite3.c.

#define disable_simulated_io_errors ( )

Definition at line 45370 of file sqlite3.c.

#define DO_OS_MALLOC_TEST ( x )

Definition at line 16516 of file sqlite3.c.

#define DOTLOCK_SUFFIX ".lock"

Definition at line 27532 of file sqlite3.c.

#define EIGHT_BYTE_ALIGNMENT ( X ) ((((char*)(X) - (char*)0)&7)==0)

Definition at line 9089 of file sqlite3.c.

#define enable_simulated_io_errors ( )

Definition at line 45371 of file sqlite3.c.

#define enable_simulated_io_errors ( )

Definition at line 45371 of file sqlite3.c.

#define ENC ( db ) ((db)->enc)

Definition at line 11110 of file sqlite3.c.

#define EP_Agg 0x000002 /* Contains one or more aggregate functions */

Definition at line 11973 of file sqlite3.c.

#define EP_CanBeNull 0x100000 /* Can be null despite NOT NULL constraint */

Definition at line 11992 of file sqlite3.c.

#define EP_Collate 0x000100 /* Tree contains a TK_COLLATE operator */

Definition at line 11980 of file sqlite3.c.

#define EP_ConstFunc 0x080000 /* Node is a SQLITE_FUNC_CONSTANT function */

Definition at line 11991 of file sqlite3.c.

#define EP_DblQuoted 0x000040 /* token.z was originally in "..." */

Definition at line 11978 of file sqlite3.c.

#define EP_Distinct 0x000010 /* Aggregate function with DISTINCT keyword */

Definition at line 11976 of file sqlite3.c.

#define EP_Error 0x000008 /* Expression contains one or more errors */

Definition at line 11975 of file sqlite3.c.

#define EP_FromJoin 0x000001 /* Originates in ON/USING clause of outer join */

Definition at line 11972 of file sqlite3.c.

#define EP_Generic 0x000200 /* Ignore COLLATE or affinity on this tree */

Definition at line 11981 of file sqlite3.c.

#define EP_InfixFunc 0x000080 /* True for an infix function: LIKE, GLOB, etc */

Definition at line 11979 of file sqlite3.c.

#define EP_IntValue 0x000400 /* Integer value contained in u.iValue */

Definition at line 11982 of file sqlite3.c.

#define EP_MemToken 0x010000 /* Need to sqlite3DbFree() Expr.zToken */

Definition at line 11988 of file sqlite3.c.

#define EP_NoReduce 0x020000 /* Cannot EXPRDUP_REDUCE this Expr */

Definition at line 11989 of file sqlite3.c.

#define EP_Propagate (EP_Collate|EP_Subquery) /* Propagate these bits up tree */

Definition at line 11998 of file sqlite3.c.

#define EP_Reduced 0x002000 /* Expr struct EXPR_REDUCEDSIZE bytes only */

Definition at line 11985 of file sqlite3.c.

#define EP_Resolved 0x000004 /* IDs have been resolved to COLUMNs */

Definition at line 11974 of file sqlite3.c.

#define EP_Skip 0x001000 /* COLLATE, AS, or UNLIKELY */

Definition at line 11984 of file sqlite3.c.

#define EP_Static 0x008000 /* Held in memory not obtained from malloc() */

Definition at line 11987 of file sqlite3.c.

#define EP_Subquery 0x200000 /* Tree contains a TK_SELECT operator */

Definition at line 11993 of file sqlite3.c.

#define EP_TokenOnly 0x004000 /* Expr struct EXPR_TOKENONLYSIZE bytes only */

Definition at line 11986 of file sqlite3.c.

#define EP_Unlikely 0x040000 /* unlikely() or likelihood() function */

Definition at line 11990 of file sqlite3.c.

#define EP_VarSelect 0x000020 /* pSelect is correlated, not constant */

Definition at line 11977 of file sqlite3.c.

#define EP_xIsSelect 0x000800 /* x.pSelect is valid (otherwise x.pList is) */

Definition at line 11983 of file sqlite3.c.

#define etBUFSIZE SQLITE_PRINT_BUF_SIZE /* Size of the output buffer */

Definition at line 21519 of file sqlite3.c.

#define etCHARX 9 /* Characters. %c */

Definition at line 21379 of file sqlite3.c.

#define etDYNSTRING 7 /* Dynamically allocated strings. %z */

Definition at line 21377 of file sqlite3.c.

#define etEXP 3 /* Exponentional notation. %e and %E */

Definition at line 21373 of file sqlite3.c.

#define etFLOAT 2 /* Floating point. %f */

Definition at line 21372 of file sqlite3.c.

#define etGENERIC 4 /* Floating or exponential, depending on exponent. %g */

Definition at line 21374 of file sqlite3.c.

#define etINVALID 0 /* Any unrecognized conversion type */

Definition at line 21390 of file sqlite3.c.

#define etORDINAL 16 /* %r -> 1st, 2nd, 3rd, 4th, etc. English only */

Definition at line 21388 of file sqlite3.c.

#define etPERCENT 8 /* Percent symbol. %% */

Definition at line 21378 of file sqlite3.c.

#define etPOINTER 14 /* The %p conversion */

Definition at line 21386 of file sqlite3.c.

#define etRADIX 1 /* Integer types. %d, %x, %o, and so forth */

Definition at line 21371 of file sqlite3.c.

#define etSIZE 5 /* Return number of characters processed so far. %n */

Definition at line 21375 of file sqlite3.c.

#define etSQLESCAPE 10 /* Strings with '\'' doubled. %q */

Definition at line 21381 of file sqlite3.c.

#define etSQLESCAPE2

Value:

11 /* Strings with '\'' doubled and enclosed in '',

NULL pointers replaced by SQL NULL. %Q */

Definition at line 21382 of file sqlite3.c.

#define etSQLESCAPE3 15 /* %w -> Strings with '\"' doubled */

Definition at line 21387 of file sqlite3.c.

#define etSRCLIST 13 /* a pointer to a SrcList */

Definition at line 21385 of file sqlite3.c.

#define etSTRING 6 /* Strings. %s */

Definition at line 21376 of file sqlite3.c.

#define etTOKEN 12 /* a pointer to a Token structure */

Definition at line 21384 of file sqlite3.c.

#define EXCLUSIVE_LOCK 4

Definition at line 10629 of file sqlite3.c.

#define ExpandBlob ( P ) (((P)->flags&MEM_Zero)?sqlite3VdbeMemExpandBlob(P):0)

Definition at line 14988 of file sqlite3.c.

#define explainSetInteger	(	a,
		b
	)	a = b

Definition at line 107587 of file sqlite3.c.

#define EXPR_FULLSIZE sizeof(Expr) /* Full size */

Definition at line 12024 of file sqlite3.c.

#define EXPR_REDUCEDSIZE offsetof(Expr,iTable) /* Common features */

Definition at line 12025 of file sqlite3.c.

#define EXPR_TOKENONLYSIZE offsetof(Expr,pLeft) /* Fewer features */

Definition at line 12026 of file sqlite3.c.

#define ExprClearProperty	(	E,
		P
	)	(E)->flags&=~(P)

Definition at line 12007 of file sqlite3.c.

#define EXPRDUP_REDUCE 0x0001 /* Used reduced-size Expr nodes */

Definition at line 12032 of file sqlite3.c.

#define ExprHasAllProperty	(	E,
		P
	)	(((E)->flags&(P))==(P))

Definition at line 12005 of file sqlite3.c.

#define ExprHasProperty	(	E,
		P
	)	(((E)->flags&(P))!=0)

Definition at line 12004 of file sqlite3.c.

#define ExprSetProperty	(	E,
		P
	)	(E)->flags\|=(P)

Definition at line 12006 of file sqlite3.c.

#define ExprSetVVAProperty	(	E,
		P
	)

Definition at line 12016 of file sqlite3.c.

#define EXTRA_SIZE sizeof(MemPage)

Definition at line 52418 of file sqlite3.c.

#define fdatasync fsync

Definition at line 28871 of file sqlite3.c.

#define FILEHANDLEID ( fd ) ((int)fd)

Definition at line 41795 of file sqlite3.c.

#define findCell	(	P,
		I
	)	((P)->aData + ((P)->maskPage & get2byte(&(P)->aCellIdx[2*(I)])))

Definition at line 54039 of file sqlite3.c.

#define findCellv2	(	D,
		M,
		O,
		I
	)	(D+(M&get2byte(D+(O+2*(I)))))

Definition at line 54041 of file sqlite3.c.

#define FLAG_INTERN 2 /* True if for internal use only */

Definition at line 21415 of file sqlite3.c.

#define FLAG_SIGNED 1 /* True if the value to convert is signed */

Definition at line 21414 of file sqlite3.c.

#define FLAG_STRING 4 /* Allow infinity precision */

Definition at line 21416 of file sqlite3.c.

#define FOUR_BYTE_INT ( x ) (16777216*(i8)((x)[0])|((x)[1]<<16)|((x)[2]<<8)|(x)[3])

Definition at line 67855 of file sqlite3.c.

#define FOUR_BYTE_UINT ( x ) (((u32)(x)[0]<<24)|((x)[1]<<16)|((x)[2]<<8)|(x)[3])

Definition at line 67854 of file sqlite3.c.

#define FULLY_WITHIN 2 /* Object fully contained within query region */

Definition at line 8030 of file sqlite3.c.

#define FUNC_PERFECT_MATCH 6 /* The score for a perfect match */

Definition at line 95363 of file sqlite3.c.

#define FUNCTION	(	zName,
		nArg,
		iArg,
		bNC,
		xFunc
	)

Value:

{nArg, SQLITE_FUNC_CONSTANT|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \

SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, #zName, 0, 0}

SQLITE_UTF8

#define SQLITE_UTF8

Definition: sqlite3.c:4463

SQLITE_FUNC_CONSTANT

#define SQLITE_FUNC_CONSTANT

Definition: sqlite3.c:11250

SQLITE_INT_TO_PTR

#define SQLITE_INT_TO_PTR(X)

Definition: sqlite3.c:8306

SQLITE_FUNC_NEEDCOLL

#define SQLITE_FUNC_NEEDCOLL

Definition: sqlite3.c:11244

Definition at line 11281 of file sqlite3.c.

#define FUNCTION2	(	zName,
		nArg,
		iArg,
		bNC,
		xFunc,
		extraFlags
	)

Value:

{nArg,SQLITE_FUNC_CONSTANT|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL)|extraFlags,\

SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, #zName, 0, 0}

SQLITE_UTF8

#define SQLITE_UTF8

Definition: sqlite3.c:4463

SQLITE_FUNC_CONSTANT

#define SQLITE_FUNC_CONSTANT

Definition: sqlite3.c:11250

SQLITE_INT_TO_PTR

#define SQLITE_INT_TO_PTR(X)

Definition: sqlite3.c:8306

SQLITE_FUNC_NEEDCOLL

#define SQLITE_FUNC_NEEDCOLL

Definition: sqlite3.c:11244

Definition at line 11287 of file sqlite3.c.

#define get2byte ( x ) ((x)[0]<<8 | (x)[1])

Definition at line 52791 of file sqlite3.c.

#define get2byteNotZero ( X ) (((((int)get2byte(X))-1)&0xffff)+1)

Definition at line 53126 of file sqlite3.c.

#define get4byte sqlite3Get4byte

Definition at line 52793 of file sqlite3.c.

#define getCellInfo ( pCur )

Value:

if( pCur->info.nSize==0 ){                                                   \
    int iPage = pCur->iPage;                                                   \
    btreeParseCell(pCur->apPage[iPage],pCur->aiIdx[iPage],&pCur->info);        \
    pCur->curFlags |= BTCF_ValidNKey;                                          \
  }else{                                                                       \
    assertCellInfo(pCur);                                                      \
  }

Definition at line 57070 of file sqlite3.c.

#define getVarint sqlite3GetVarint

Definition at line 13402 of file sqlite3.c.

#define getVarint32	(	A,
		B
	)	(u8)(((A)<(u8)0x80)?((B)=(u32)(A)),1:sqlite3GetVarint32((A),(u32 *)&(B)))

Definition at line 13397 of file sqlite3.c.

#define GLOBAL	(	t,
		v
	)	v

Definition at line 9237 of file sqlite3.c.

#define GlobUpperToLower ( A ) if( A<=0x7f ){ A = sqlite3UpperToLower[A]; }

Definition at line 97019 of file sqlite3.c.

#define GlobUpperToLowerAscii ( A ) A = sqlite3UpperToLower[A]

Definition at line 97020 of file sqlite3.c.

#define HASHTABLE_HASH_1 383 /* Should be prime */

Definition at line 49427 of file sqlite3.c.

#define HASHTABLE_NPAGE 4096 /* Must be power of 2 */

Definition at line 49426 of file sqlite3.c.

#define HASHTABLE_NPAGE_ONE (HASHTABLE_NPAGE - (WALINDEX_HDR_SIZE/sizeof(u32)))

Definition at line 49435 of file sqlite3.c.

#define HASHTABLE_NSLOT (HASHTABLE_NPAGE*2) /* Must be a power of 2 */

Definition at line 49428 of file sqlite3.c.

#define HasRowid ( X ) (((X)->tabFlags & TF_WithoutRowid)==0)

Definition at line 11571 of file sqlite3.c.

#define HAVE_FULLFSYNC 0

Definition at line 28882 of file sqlite3.c.

#define HAVE_MREMAP 0

Definition at line 25770 of file sqlite3.c.

#define IdChar ( C ) ((sqlite3CtypeMap[(unsigned char)C]&0x46)!=0)

Definition at line 127176 of file sqlite3.c.

#define IfNotOmitAV ( expr ) (expr)

Definition at line 53142 of file sqlite3.c.

#define IgnorableOrderby ( X ) ((X->eDest)<=SRT_DistQueue)

Definition at line 12393 of file sqlite3.c.

#define IN_DECLARE_VTAB (pParse->declareVtab)

Definition at line 12611 of file sqlite3.c.

#define IN_INDEX_EPH 2 /* Search an ephemeral b-tree */

Definition at line 13671 of file sqlite3.c.

#define IN_INDEX_INDEX_ASC 3 /* Existing index ASCENDING */

Definition at line 13672 of file sqlite3.c.

#define IN_INDEX_INDEX_DESC 4 /* Existing index DESCENDING */

Definition at line 13673 of file sqlite3.c.

#define IN_INDEX_LOOP 0x0004 /* IN operator used as a loop */

Definition at line 13680 of file sqlite3.c.

#define IN_INDEX_MEMBERSHIP 0x0002 /* IN operator used for membership test */

Definition at line 13679 of file sqlite3.c.

#define IN_INDEX_NOOP 5 /* No table available. Use comparisons */

Definition at line 13674 of file sqlite3.c.

#define IN_INDEX_NOOP_OK 0x0001 /* OK to return IN_INDEX_NOOP */

Definition at line 13678 of file sqlite3.c.

#define IN_INDEX_ROWID 1 /* Search the rowid of the table */

Definition at line 13670 of file sqlite3.c.

#define INCRINIT_NORMAL 0

Definition at line 79991 of file sqlite3.c.

#define INCRINIT_ROOT 2

Definition at line 79993 of file sqlite3.c.

#define INCRINIT_TASK 1

Definition at line 79992 of file sqlite3.c.

#define initMaskSet ( P ) (P)->n=0

Definition at line 116456 of file sqlite3.c.

#define INT16_TYPE short int

Definition at line 8934 of file sqlite3.c.

#define INT8_TYPE signed char

Definition at line 8948 of file sqlite3.c.

#define INTERFACE 1

Definition at line 123405 of file sqlite3.c.

#define invalidateOverflowCache ( pCur ) (pCur->curFlags &= ~BTCF_ValidOvfl)

Definition at line 53541 of file sqlite3.c.

#define IOMETHODS	(	FINDER,
		METHOD,
		VERSION,
		CLOSE,
		LOCK,
		UNLOCK,
		CKLOCK,
		SHMMAP
	)

Value:

static const sqlite3_io_methods METHOD = {                                   \
   VERSION,                    /* iVersion */                                \
   CLOSE,                      /* xClose */                                  \
   unixRead,                   /* xRead */                                   \
   unixWrite,                  /* xWrite */                                  \
   unixTruncate,               /* xTruncate */                               \
   unixSync,                   /* xSync */                                   \
   unixFileSize,               /* xFileSize */                               \
   LOCK,                       /* xLock */                                   \
   UNLOCK,                     /* xUnlock */                                 \
   CKLOCK,                     /* xCheckReservedLock */                      \
   unixFileControl,            /* xFileControl */                            \
   unixSectorSize,             /* xSectorSize */                             \
   unixDeviceCharacteristics,  /* xDeviceCapabilities */                     \
   SHMMAP,                     /* xShmMap */                                 \
   unixShmLock,                /* xShmLock */                                \
   unixShmBarrier,             /* xShmBarrier */                             \
   unixShmUnmap,               /* xShmUnmap */                               \
   unixFetch,                  /* xFetch */                                  \
   unixUnfetch,                /* xUnfetch */                                \
};                                                                           \
static const sqlite3_io_methods *FINDER##Impl(const char *z, unixFile *p){   \
  UNUSED_PARAMETER(z); UNUSED_PARAMETER(p);                                  \
  return &METHOD;                                                            \
}                                                                            \
static const sqlite3_io_methods *(*const FINDER)(const char*,unixFile *p)    \
    = FINDER##Impl;

Definition at line 30455 of file sqlite3.c.

#define IOTRACE ( A )

Definition at line 13733 of file sqlite3.c.

#define IS_BIG_INT ( X ) (((X)&~(i64)0xffffffff)!=0)

Definition at line 8517 of file sqlite3.c.

#define IS_LOCK_ERROR ( x ) ((x != SQLITE_OK) && (x != SQLITE_BUSY))

Definition at line 25419 of file sqlite3.c.

#define ISAUTOVACUUM (pBt->autoVacuum)

Definition at line 52758 of file sqlite3.c.

#define IsHiddenColumn ( X ) (((X)->colFlags & COLFLAG_HIDDEN)!=0)

Definition at line 11564 of file sqlite3.c.

#define isOpen ( pFd ) ((pFd)->pMethods)

Definition at line 42474 of file sqlite3.c.

#define IsPowerOfTwo ( X ) (((X)&((X)-1))==0)

Definition at line 9203 of file sqlite3.c.

#define IsPrimaryKeyIndex ( X ) ((X)->idxType==SQLITE_IDXTYPE_PRIMARYKEY)

Definition at line 11771 of file sqlite3.c.

#define isSorter ( x ) ((x)->pSorter!=0)

Definition at line 70943 of file sqlite3.c.

#define IsStat3 0

Definition at line 88221 of file sqlite3.c.

#define IsStat34 (IsStat3+IsStat4) /* 1 for STAT3 or STAT4. 0 otherwise */

Definition at line 88225 of file sqlite3.c.

#define IsStat4 0

Definition at line 88220 of file sqlite3.c.

#define IsUniqueIndex ( X ) ((X)->onError!=OE_None)

Definition at line 11774 of file sqlite3.c.

#define IsVirtual ( X ) (((X)->tabFlags & TF_Virtual)!=0)

Definition at line 11563 of file sqlite3.c.

#define JOURNAL_CHUNKSIZE ((int)(1024-sizeof(FileChunk*)))

Definition at line 80922 of file sqlite3.c.

#define JOURNAL_HDR_SZ ( pPager ) (pPager->sectorSize)

Definition at line 42433 of file sqlite3.c.

#define JOURNAL_PG_SZ ( pPager ) ((pPager->pageSize) + 8)

Definition at line 42427 of file sqlite3.c.

#define JT_CROSS 0x0002 /* Explicit use of the CROSS keyword */

Definition at line 12177 of file sqlite3.c.

#define JT_ERROR 0x0040 /* unknown or unsupported join type */

Definition at line 12182 of file sqlite3.c.

#define JT_INNER 0x0001 /* Any kind of inner or cross join */

Definition at line 12176 of file sqlite3.c.

#define JT_LEFT 0x0008 /* Left outer join */

Definition at line 12179 of file sqlite3.c.

#define JT_NATURAL 0x0004 /* True for a "natural" join */

Definition at line 12178 of file sqlite3.c.

#define JT_OUTER 0x0020 /* The "OUTER" keyword is present */

Definition at line 12181 of file sqlite3.c.

#define JT_RIGHT 0x0010 /* Right outer join */

Definition at line 12180 of file sqlite3.c.

#define LARGEST_INT64 (0xffffffff|(((i64)0x7fffffff)<<32))

Definition at line 9063 of file sqlite3.c.

#define LIKEFUNC	(	zName,
		nArg,
		arg,
		flags
	)

Value:

{nArg, SQLITE_FUNC_CONSTANT|SQLITE_UTF8|flags, \

(void *)arg, 0, likeFunc, 0, 0, #zName, 0, 0}

SQLITE_UTF8

#define SQLITE_UTF8

Definition: sqlite3.c:4463

SQLITE_FUNC_CONSTANT

#define SQLITE_FUNC_CONSTANT

Definition: sqlite3.c:11250

Definition at line 11293 of file sqlite3.c.

#define likely ( X ) (X)

Definition at line 8526 of file sqlite3.c.

#define LONGDOUBLE_TYPE long double

Definition at line 8952 of file sqlite3.c.

#define MASKBIT ( n ) (((Bitmask)1)<<(n))

Definition at line 12121 of file sqlite3.c.

#define MASKBIT32 ( n ) (((unsigned int)1)<<(n))

Definition at line 12122 of file sqlite3.c.

#define MASTER_NAME "sqlite_master"

Definition at line 9181 of file sqlite3.c.

#define MASTER_ROOT 1

Definition at line 9187 of file sqlite3.c.

#define MAX	(	A,
		B
	)	((A)>(B)?(A):(B))

Definition at line 8892 of file sqlite3.c.

#define MAX_6BYTE ((((i64)0x00008000)<<32)-1)

#define MAX_PATHNAME 512

Definition at line 25409 of file sqlite3.c.

#define MAX_ROWID (i64)( (((u64)0x7fffffff)<<32) | (u64)0xffffffff )

#define MAX_SECTOR_SIZE 0x10000

Definition at line 42092 of file sqlite3.c.

#define mem0 GLOBAL(struct Mem0Global, mem0)

Definition at line 20598 of file sqlite3.c.

#define MEM_AffMask 0x001f /* Mask of affinity bits */

Definition at line 14705 of file sqlite3.c.

#define MEM_Agg 0x2000 /* Mem.z points to an agg function context */

Definition at line 14722 of file sqlite3.c.

#define MEM_Blob 0x0010 /* Value is a BLOB */

Definition at line 14704 of file sqlite3.c.

#define MEM_Cleared 0x0100 /* NULL set by OP_Null, not from data */

Definition at line 14709 of file sqlite3.c.

#define MEM_Dyn 0x0400 /* Need to call Mem.xDel() on Mem.z */

Definition at line 14719 of file sqlite3.c.

#define MEM_Ephem 0x1000 /* Mem.z points to an ephemeral string */

Definition at line 14721 of file sqlite3.c.

#define MEM_Frame 0x0040 /* Value is a VdbeFrame object */

Definition at line 14707 of file sqlite3.c.

#define MEM_Int 0x0004 /* Value is an integer */

Definition at line 14702 of file sqlite3.c.

#define MEM_Null 0x0001 /* Value is NULL */

Definition at line 14700 of file sqlite3.c.

#define MEM_Real 0x0008 /* Value is a real number */

Definition at line 14703 of file sqlite3.c.

#define MEM_RowSet 0x0020 /* Value is a RowSet object */

Definition at line 14706 of file sqlite3.c.

#define MEM_Static 0x0800 /* Mem.z points to a static string */

Definition at line 14720 of file sqlite3.c.

#define MEM_Str 0x0002 /* Value is a string */

Definition at line 14701 of file sqlite3.c.

#define MEM_Term 0x0200 /* String rep is nul terminated */

Definition at line 14718 of file sqlite3.c.

#define MEM_TypeMask 0x01ff /* Mask of type bits */

Definition at line 14710 of file sqlite3.c.

#define MEM_Undefined 0x0080 /* Value is undefined */

Definition at line 14708 of file sqlite3.c.

#define MEM_Zero 0x4000 /* Mem.i contains count of 0s appended to blob */

Definition at line 14723 of file sqlite3.c.

#define memAboutToChange	(	P,
		M
	)

Definition at line 70811 of file sqlite3.c.

#define MEMCELLSIZE offsetof(Mem,zMalloc)

Definition at line 63893 of file sqlite3.c.

#define MEMDB pPager->memDb

Definition at line 42444 of file sqlite3.c.

#define MemSetTypeFlag	(	p,
		f
	)	((p)->flags = ((p)->flags&~(MEM_TypeMask\|MEM_Zero))\|f)

Definition at line 14732 of file sqlite3.c.

#define MEMTYPE_HEAP 0x01 /* General heap allocations */

Definition at line 13774 of file sqlite3.c.

#define MEMTYPE_LOOKASIDE 0x02 /* Heap that might have been lookaside */

Definition at line 13775 of file sqlite3.c.

#define MEMTYPE_PCACHE 0x08 /* Page cache allocations */

Definition at line 13777 of file sqlite3.c.

#define MEMTYPE_SCRATCH 0x04 /* Scratch allocations */

Definition at line 13776 of file sqlite3.c.

#define MIN	(	A,
		B
	)	((A)<(B)?(A):(B))

Definition at line 8891 of file sqlite3.c.

#define MUTEX_LOGIC ( X ) X

Definition at line 10823 of file sqlite3.c.

#define MX_CELL ( pBt ) ((pBt->pageSize-8)/6)

Definition at line 52341 of file sqlite3.c.

#define MX_CELL_SIZE ( pBt ) ((int)(pBt->pageSize-8))

Definition at line 52334 of file sqlite3.c.

#define N_OR_COST 3

Definition at line 115889 of file sqlite3.c.

#define N_SORT_BUCKET 32

Definition at line 39845 of file sqlite3.c.

#define NB (NN*2+1) /* Total pages involved in the balance */

Definition at line 59492 of file sqlite3.c.

#define NC_AllowAgg 0x0001 /* Aggregate functions are allowed here */

Definition at line 12250 of file sqlite3.c.

#define NC_HasAgg 0x0002 /* One or more aggregate functions seen */

Definition at line 12251 of file sqlite3.c.

#define NC_InAggFunc 0x0008 /* True if analyzing arguments to an agg func */

Definition at line 12253 of file sqlite3.c.

#define NC_IsCheck 0x0004 /* True if resolving names in a CHECK constraint */

Definition at line 12252 of file sqlite3.c.

#define NC_MinMaxAgg 0x1000 /* min/max aggregates seen. See note above */

Definition at line 12255 of file sqlite3.c.

#define NC_PartIdx 0x0010 /* True if resolving a partial index WHERE */

Definition at line 12254 of file sqlite3.c.

#define NDEBUG 1

Definition at line 8427 of file sqlite3.c.

#define NEVER ( X ) (X)

Definition at line 8509 of file sqlite3.c.

#define NN 1 /* Number of neighbors on either side of pPage */

Definition at line 59491 of file sqlite3.c.

#define NO_LOCK 0

Definition at line 10625 of file sqlite3.c.

#define noopFunc versionFunc /* Substitute function - never called */

Definition at line 96897 of file sqlite3.c.

#define NOT_WITHIN 0 /* Object completely outside of query region */

Definition at line 8028 of file sqlite3.c.

#define O_BINARY 0

Definition at line 25750 of file sqlite3.c.

#define O_LARGEFILE 0

Definition at line 25740 of file sqlite3.c.

#define O_NOFOLLOW 0

Definition at line 25747 of file sqlite3.c.

#define OE_Abort 2 /* Back out changes but do no rollback transaction */

Definition at line 11645 of file sqlite3.c.

#define OE_Cascade 9 /* Cascade the changes */

Definition at line 11653 of file sqlite3.c.

#define OE_Default 10 /* Do whatever the default action is */

Definition at line 11655 of file sqlite3.c.

#define OE_Fail 3 /* Stop the operation but leave all prior changes */

Definition at line 11646 of file sqlite3.c.

#define OE_Ignore 4 /* Ignore the error. Do not do the INSERT or UPDATE */

Definition at line 11647 of file sqlite3.c.

#define OE_None 0 /* There is no constraint to check */

Definition at line 11643 of file sqlite3.c.

#define OE_Replace 5 /* Delete existing record, then do INSERT or UPDATE */

Definition at line 11648 of file sqlite3.c.

#define OE_Restrict 6 /* OE_Abort for IMMEDIATE, OE_Rollback for DEFERRED */

Definition at line 11650 of file sqlite3.c.

#define OE_Rollback 1 /* Fail the operation and rollback the transaction */

Definition at line 11644 of file sqlite3.c.

#define OE_SetDflt 8 /* Set the foreign key value to its default */

Definition at line 11652 of file sqlite3.c.

#define OE_SetNull 7 /* Set the foreign key value to NULL */

Definition at line 11651 of file sqlite3.c.

#define offsetof	(	STRUCTURE,
		FIELD
	)	((int)((char)&((STRUCTURE)0)->FIELD))

Definition at line 8885 of file sqlite3.c.

#define OMIT_TEMPDB 0

Definition at line 8828 of file sqlite3.c.

#define ONE_BYTE_INT ( x ) ((i8)(x)[0])

Definition at line 67851 of file sqlite3.c.

#define OP_Add 89 /* same as TK_PLUS, synopsis: r[P3]=r[P1]+r[P2] */

Definition at line 9847 of file sqlite3.c.

#define OP_AddImm 37 /* synopsis: r[P1]=r[P1]+P2 */

Definition at line 9795 of file sqlite3.c.

#define OP_Affinity 48 /* synopsis: affinity(r[P1@P2]) */

Definition at line 9806 of file sqlite3.c.

#define OP_AggFinal 142 /* synopsis: accum=r[P1] N=P2 */

Definition at line 9900 of file sqlite3.c.

#define OP_AggStep 10 /* synopsis: accum=r[P3] step(r[P2@P5]) */

Definition at line 9768 of file sqlite3.c.

#define OP_And 72 /* same as TK_AND, synopsis: r[P3]=(r[P1] && r[P2]) */

Definition at line 9830 of file sqlite3.c.

#define OP_AutoCommit 3

Definition at line 9761 of file sqlite3.c.

#define OP_BitAnd 85 /* same as TK_BITAND, synopsis: r[P3]=r[P1]&r[P2] */

Definition at line 9843 of file sqlite3.c.

#define OP_BitNot 96 /* same as TK_BITNOT, synopsis: r[P1]= ~r[P1] */

Definition at line 9854 of file sqlite3.c.

#define OP_BitOr 86 /* same as TK_BITOR, synopsis: r[P3]=r[P1]|r[P2] */

Definition at line 9844 of file sqlite3.c.

#define OP_Blob 30 /* synopsis: r[P2]=P4 (len=P1) */

Definition at line 9788 of file sqlite3.c.

#define OP_Cast 40 /* synopsis: affinity(r[P1]) */

Definition at line 9798 of file sqlite3.c.

#define OP_Checkpoint 11

Definition at line 9769 of file sqlite3.c.

#define OP_Clear 118

Definition at line 9876 of file sqlite3.c.

#define OP_Close 61

Definition at line 9819 of file sqlite3.c.

#define OP_CollSeq 36

Definition at line 9794 of file sqlite3.c.

#define OP_Column 47 /* synopsis: r[P3]=PX */

Definition at line 9805 of file sqlite3.c.

#define OP_Compare 42 /* synopsis: r[P1@P3] <-> r[P2@P3] */

Definition at line 9800 of file sqlite3.c.

#define OP_Concat 94 /* same as TK_CONCAT, synopsis: r[P3]=r[P2]+r[P1] */

Definition at line 9852 of file sqlite3.c.

#define OP_Copy 33 /* synopsis: r[P2@P3+1]=r[P1@P3+1] */

Definition at line 9791 of file sqlite3.c.

#define OP_Count 50 /* synopsis: r[P2]=count() */

Definition at line 9808 of file sqlite3.c.

#define OP_CreateIndex 120 /* synopsis: r[P2]=root iDb=P1 */

Definition at line 9878 of file sqlite3.c.

#define OP_CreateTable 121 /* synopsis: r[P2]=root iDb=P1 */

Definition at line 9879 of file sqlite3.c.

#define OP_DecrJumpZero 140 /* synopsis: if (--r[P1])==0 goto P2 */

Definition at line 9898 of file sqlite3.c.

#define OP_Delete 95

Definition at line 9853 of file sqlite3.c.

#define OP_Destroy 117

Definition at line 9875 of file sqlite3.c.

#define OP_Divide 92 /* same as TK_SLASH, synopsis: r[P3]=r[P2]/r[P1] */

Definition at line 9850 of file sqlite3.c.

#define OP_DropIndex 125

Definition at line 9883 of file sqlite3.c.

#define OP_DropTable 124

Definition at line 9882 of file sqlite3.c.

#define OP_DropTrigger 126

Definition at line 9884 of file sqlite3.c.

#define OP_EndCoroutine 21

Definition at line 9779 of file sqlite3.c.

#define OP_Eq 79 /* same as TK_EQ, synopsis: if r[P1]==r[P3] goto P2 */

Definition at line 9837 of file sqlite3.c.

#define OP_Expire 144

Definition at line 9902 of file sqlite3.c.

#define OP_Explain 157

Definition at line 9915 of file sqlite3.c.

#define OP_FkCounter 134 /* synopsis: fkctr[P1]+=P2 */

Definition at line 9892 of file sqlite3.c.

#define OP_FkIfZero 135 /* synopsis: if fkctr[P1]==0 goto P2 */

Definition at line 9893 of file sqlite3.c.

#define OP_Found 69 /* synopsis: key=r[P3@P4] */

Definition at line 9827 of file sqlite3.c.

#define OP_Function 1 /* synopsis: r[P3]=func(r[P2@P5]) */

Definition at line 9759 of file sqlite3.c.

#define OP_Ge 83 /* same as TK_GE, synopsis: if r[P1]>=r[P3] goto P2 */

Definition at line 9841 of file sqlite3.c.

#define OP_Gosub 17

Definition at line 9775 of file sqlite3.c.

#define OP_Goto 16

Definition at line 9774 of file sqlite3.c.

#define OP_Gt 80 /* same as TK_GT, synopsis: if r[P1]>r[P3] goto P2 */

Definition at line 9838 of file sqlite3.c.

#define OP_Halt 24

Definition at line 9782 of file sqlite3.c.

#define OP_HaltIfNull 23 /* synopsis: if r[P3]=null halt */

Definition at line 9781 of file sqlite3.c.

#define OP_IdxDelete 111 /* synopsis: key=r[P2@P3] */

Definition at line 9869 of file sqlite3.c.

#define OP_IdxGE 116 /* synopsis: key=r[P3@P4] */

Definition at line 9874 of file sqlite3.c.

#define OP_IdxGT 114 /* synopsis: key=r[P3@P4] */

Definition at line 9872 of file sqlite3.c.

#define OP_IdxInsert 110 /* synopsis: key=r[P2] */

Definition at line 9868 of file sqlite3.c.

#define OP_IdxLE 113 /* synopsis: key=r[P3@P4] */

Definition at line 9871 of file sqlite3.c.

#define OP_IdxLT 115 /* synopsis: key=r[P3@P4] */

Definition at line 9873 of file sqlite3.c.

#define OP_IdxRowid 112 /* synopsis: r[P2]=rowid */

Definition at line 9870 of file sqlite3.c.

#define OP_If 45

Definition at line 9803 of file sqlite3.c.

#define OP_IfNeg 138 /* synopsis: r[P1]+=P3, if r[P1]<0 goto P2 */

Definition at line 9896 of file sqlite3.c.

#define OP_IfNot 46

Definition at line 9804 of file sqlite3.c.

#define OP_IfNotZero 139 /* synopsis: if r[P1]!=0 then r[P1]+=P3, goto P2 */

Definition at line 9897 of file sqlite3.c.

#define OP_IfPos 137 /* synopsis: if r[P1]>0 goto P2 */

Definition at line 9895 of file sqlite3.c.

#define OP_IncrVacuum 143

Definition at line 9901 of file sqlite3.c.

#define OP_Init 155 /* synopsis: Start at P2 */

Definition at line 9913 of file sqlite3.c.

#define OP_InitCoroutine 20

Definition at line 9778 of file sqlite3.c.

#define OP_Insert 75 /* synopsis: intkey=r[P3] data=r[P2] */

Definition at line 9833 of file sqlite3.c.

#define OP_InsertInt 84 /* synopsis: intkey=P3 data=r[P2] */

Definition at line 9842 of file sqlite3.c.

#define OP_Int64 26 /* synopsis: r[P2]=P4 */

Definition at line 9784 of file sqlite3.c.

#define OP_Integer 25 /* synopsis: r[P2]=P1 */

Definition at line 9783 of file sqlite3.c.

#define OP_IntegrityCk 127

Definition at line 9885 of file sqlite3.c.

#define OP_IsNull 76 /* same as TK_ISNULL, synopsis: if r[P1]==NULL goto P2 */

Definition at line 9834 of file sqlite3.c.

#define OP_JournalMode 12

Definition at line 9770 of file sqlite3.c.

#define OP_Jump 43

Definition at line 9801 of file sqlite3.c.

#define OP_JumpZeroIncr 141 /* synopsis: if (r[P1]++)==0 ) goto P2 */

Definition at line 9899 of file sqlite3.c.

#define OP_Last 105

Definition at line 9863 of file sqlite3.c.

#define OP_Le 81 /* same as TK_LE, synopsis: if r[P1]<=r[P3] goto P2 */

Definition at line 9839 of file sqlite3.c.

#define OP_LoadAnalysis 123

Definition at line 9881 of file sqlite3.c.

#define OP_Lt 82 /* same as TK_LT, synopsis: if r[P1]<r[P3] goto P2 */

Definition at line 9840 of file sqlite3.c.

#define OP_MakeRecord 49 /* synopsis: r[P3]=mkrec(r[P1@P2]) */

Definition at line 9807 of file sqlite3.c.

#define OP_MaxPgcnt 154

Definition at line 9912 of file sqlite3.c.

#define OP_MemMax 136 /* synopsis: r[P1]=max(r[P1],r[P2]) */

Definition at line 9894 of file sqlite3.c.

#define OP_Move 32 /* synopsis: r[P2@P3]=r[P1@P3] */

Definition at line 9790 of file sqlite3.c.

#define OP_Multiply 91 /* same as TK_STAR, synopsis: r[P3]=r[P1]*r[P2] */

Definition at line 9849 of file sqlite3.c.

#define OP_MustBeInt 38

Definition at line 9796 of file sqlite3.c.

#define OP_Ne 78 /* same as TK_NE, synopsis: if r[P1]!=r[P3] goto P2 */

Definition at line 9836 of file sqlite3.c.

#define OP_NewRowid 74 /* synopsis: r[P2]=rowid */

Definition at line 9832 of file sqlite3.c.

#define OP_Next 9

Definition at line 9767 of file sqlite3.c.

#define OP_NextIfOpen 7

Definition at line 9765 of file sqlite3.c.

#define OP_NoConflict 67 /* synopsis: key=r[P3@P4] */

Definition at line 9825 of file sqlite3.c.

#define OP_Noop 156

Definition at line 9914 of file sqlite3.c.

#define OP_Not 19 /* same as TK_NOT, synopsis: r[P2]= !r[P1] */

Definition at line 9777 of file sqlite3.c.

#define OP_NotExists 70 /* synopsis: intkey=r[P3] */

Definition at line 9828 of file sqlite3.c.

#define OP_NotFound 68 /* synopsis: key=r[P3@P4] */

Definition at line 9826 of file sqlite3.c.

#define OP_NotNull 77 /* same as TK_NOTNULL, synopsis: if r[P1]!=NULL goto P2 */

Definition at line 9835 of file sqlite3.c.

#define OP_Null 28 /* synopsis: r[P2..P3]=NULL */

Definition at line 9786 of file sqlite3.c.

#define OP_NullRow 104

Definition at line 9862 of file sqlite3.c.

#define OP_Once 44

Definition at line 9802 of file sqlite3.c.

#define OP_OpenAutoindex 56 /* synopsis: nColumn=P2 */

Definition at line 9814 of file sqlite3.c.

#define OP_OpenEphemeral 57 /* synopsis: nColumn=P2 */

Definition at line 9815 of file sqlite3.c.

#define OP_OpenPseudo 60 /* synopsis: P3 columns in r[P2] */

Definition at line 9818 of file sqlite3.c.

#define OP_OpenRead 54 /* synopsis: root=P2 iDb=P3 */

Definition at line 9812 of file sqlite3.c.

#define OP_OpenWrite 55 /* synopsis: root=P2 iDb=P3 */

Definition at line 9813 of file sqlite3.c.

#define OP_Or 71 /* same as TK_OR, synopsis: r[P3]=(r[P1] || r[P2]) */

Definition at line 9829 of file sqlite3.c.

#define OP_Pagecount 153

Definition at line 9911 of file sqlite3.c.

#define OP_Param 132

Definition at line 9890 of file sqlite3.c.

#define OP_ParseSchema 122

Definition at line 9880 of file sqlite3.c.

#define OP_Permutation 41

Definition at line 9799 of file sqlite3.c.

#define OP_Prev 8

Definition at line 9766 of file sqlite3.c.

#define OP_PrevIfOpen 6

Definition at line 9764 of file sqlite3.c.

#define OP_Program 131

Definition at line 9889 of file sqlite3.c.

#define OP_ReadCookie 51

Definition at line 9809 of file sqlite3.c.

#define OP_Real 133 /* same as TK_FLOAT, synopsis: r[P2]=P4 */

Definition at line 9891 of file sqlite3.c.

#define OP_RealAffinity 39

Definition at line 9797 of file sqlite3.c.

#define OP_Remainder 93 /* same as TK_REM, synopsis: r[P3]=r[P2]%r[P1] */

Definition at line 9851 of file sqlite3.c.

#define OP_ReopenIdx 53 /* synopsis: root=P2 iDb=P3 */

Definition at line 9811 of file sqlite3.c.

#define OP_ResetCount 98

Definition at line 9856 of file sqlite3.c.

#define OP_ResetSorter 119

Definition at line 9877 of file sqlite3.c.

#define OP_ResultRow 35 /* synopsis: output=r[P1@P2] */

Definition at line 9793 of file sqlite3.c.

#define OP_Return 18

Definition at line 9776 of file sqlite3.c.

#define OP_Rewind 108

Definition at line 9866 of file sqlite3.c.

#define OP_RowData 102 /* synopsis: r[P2]=data */

Definition at line 9860 of file sqlite3.c.

#define OP_Rowid 103 /* synopsis: r[P2]=rowid */

Definition at line 9861 of file sqlite3.c.

#define OP_RowKey 101 /* synopsis: r[P2]=key */

Definition at line 9859 of file sqlite3.c.

#define OP_RowSetAdd 128 /* synopsis: rowset(P1)=r[P2] */

Definition at line 9886 of file sqlite3.c.

#define OP_RowSetRead 129 /* synopsis: r[P3]=rowset(P1) */

Definition at line 9887 of file sqlite3.c.

#define OP_RowSetTest 130 /* synopsis: if r[P3] in rowset(P1) goto P2 */

Definition at line 9888 of file sqlite3.c.

#define OP_Savepoint 2

Definition at line 9760 of file sqlite3.c.

#define OP_SCopy 34 /* synopsis: r[P2]=r[P1] */

Definition at line 9792 of file sqlite3.c.

#define OP_Seek 66 /* synopsis: intkey=r[P2] */

Definition at line 9824 of file sqlite3.c.

#define OP_SeekGE 64 /* synopsis: key=r[P3@P4] */

Definition at line 9822 of file sqlite3.c.

#define OP_SeekGT 65 /* synopsis: key=r[P3@P4] */

Definition at line 9823 of file sqlite3.c.

#define OP_SeekLE 63 /* synopsis: key=r[P3@P4] */

Definition at line 9821 of file sqlite3.c.

#define OP_SeekLT 62 /* synopsis: key=r[P3@P4] */

Definition at line 9820 of file sqlite3.c.

#define OP_Sequence 73 /* synopsis: r[P2]=cursor[P1].ctr++ */

Definition at line 9831 of file sqlite3.c.

#define OP_SequenceTest 59 /* synopsis: if( cursor[P1].ctr++ ) pc = P2 */

Definition at line 9817 of file sqlite3.c.

#define OP_SetCookie 52

Definition at line 9810 of file sqlite3.c.

#define OP_ShiftLeft 87 /* same as TK_LSHIFT, synopsis: r[P3]=r[P2]<<r[P1] */

Definition at line 9845 of file sqlite3.c.

#define OP_ShiftRight 88 /* same as TK_RSHIFT, synopsis: r[P3]=r[P2]>>r[P1] */

Definition at line 9846 of file sqlite3.c.

#define OP_SoftNull 29 /* synopsis: r[P1]=NULL */

Definition at line 9787 of file sqlite3.c.

#define OP_Sort 107

Definition at line 9865 of file sqlite3.c.

#define OP_SorterCompare 99 /* synopsis: if key(P1)!=trim(r[P3],P4) goto P2 */

Definition at line 9857 of file sqlite3.c.

#define OP_SorterData 100 /* synopsis: r[P2]=data */

Definition at line 9858 of file sqlite3.c.

#define OP_SorterInsert 109

Definition at line 9867 of file sqlite3.c.

#define OP_SorterNext 5

Definition at line 9763 of file sqlite3.c.

#define OP_SorterOpen 58

Definition at line 9816 of file sqlite3.c.

#define OP_SorterSort 106

Definition at line 9864 of file sqlite3.c.

#define OP_String 27 /* synopsis: r[P2]='P4' (len=P1) */

Definition at line 9785 of file sqlite3.c.

#define OP_String8 97 /* same as TK_STRING, synopsis: r[P2]='P4' */

Definition at line 9855 of file sqlite3.c.

#define OP_Subtract 90 /* same as TK_MINUS, synopsis: r[P3]=r[P2]-r[P1] */

Definition at line 9848 of file sqlite3.c.

#define OP_TableLock 145 /* synopsis: iDb=P1 root=P2 write=P3 */

Definition at line 9903 of file sqlite3.c.

#define OP_Transaction 4

Definition at line 9762 of file sqlite3.c.

#define OP_Vacuum 13

Definition at line 9771 of file sqlite3.c.

#define OP_Variable 31 /* synopsis: r[P2]=parameter(P1,P4) */

Definition at line 9789 of file sqlite3.c.

#define OP_VBegin 146

Definition at line 9904 of file sqlite3.c.

#define OP_VColumn 150 /* synopsis: r[P3]=vcolumn(P2) */

Definition at line 9908 of file sqlite3.c.

#define OP_VCreate 147

Definition at line 9905 of file sqlite3.c.

#define OP_VDestroy 148

Definition at line 9906 of file sqlite3.c.

#define OP_VFilter 14 /* synopsis: iplan=r[P3] zplan='P4' */

Definition at line 9772 of file sqlite3.c.

#define OP_VNext 151

Definition at line 9909 of file sqlite3.c.

#define OP_VOpen 149

Definition at line 9907 of file sqlite3.c.

#define OP_VRename 152

Definition at line 9910 of file sqlite3.c.

#define OP_VUpdate 15 /* synopsis: data=r[P3@P2] */

Definition at line 9773 of file sqlite3.c.

#define OP_Yield 22

Definition at line 9780 of file sqlite3.c.

#define OpenCounter ( X )

Definition at line 25728 of file sqlite3.c.

#define OPFLAG_APPEND 0x08 /* This is likely to be an append */

Definition at line 12630 of file sqlite3.c.

#define OPFLAG_BULKCSR 0x01 /* OP_Open** used to open bulk cursor */

Definition at line 12634 of file sqlite3.c.

#define OPFLAG_EPHEM 0x01 /* OP_Column: Ephemeral output is ok */

Definition at line 12627 of file sqlite3.c.

#define OPFLAG_ISUPDATE 0x04 /* This OP_Insert is an sql UPDATE */

Definition at line 12629 of file sqlite3.c.

#define OPFLAG_LASTROWID 0x02 /* Set to update db->lastRowid */

Definition at line 12628 of file sqlite3.c.

#define OPFLAG_LENGTHARG 0x40 /* OP_Column only used for length() */

Definition at line 12632 of file sqlite3.c.

#define OPFLAG_NCHANGE 0x01 /* Set to update db->nChange */

Definition at line 12626 of file sqlite3.c.

#define OPFLAG_P2ISREG 0x04 /* P2 to OP_Open** is a register number */

Definition at line 12636 of file sqlite3.c.

#define OPFLAG_PERMUTE 0x01 /* OP_Compare: use the permutation */

Definition at line 12637 of file sqlite3.c.

#define OPFLAG_SEEKEQ 0x02 /* OP_Open** cursor uses EQ seek only */

Definition at line 12635 of file sqlite3.c.

#define OPFLAG_TYPEOFARG 0x80 /* OP_Column only used for typeof() */

Definition at line 12633 of file sqlite3.c.

#define OPFLAG_USESEEKRESULT 0x10 /* Try to avoid a seek in BtreeInsert() */

Definition at line 12631 of file sqlite3.c.

#define OPFLG_IN1 0x0002 /* in1: P1 is an input */

Definition at line 9923 of file sqlite3.c.

#define OPFLG_IN2 0x0004 /* in2: P2 is an input */

Definition at line 9924 of file sqlite3.c.

#define OPFLG_IN3 0x0008 /* in3: P3 is an input */

Definition at line 9925 of file sqlite3.c.

#define OPFLG_INITIALIZER

Value:

{\
/*   0 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01,\
/*   8 */ 0x01, 0x01, 0x00, 0x00, 0x10, 0x00, 0x01, 0x00,\
/*  16 */ 0x01, 0x01, 0x02, 0x12, 0x01, 0x02, 0x03, 0x08,\
/*  24 */ 0x00, 0x10, 0x10, 0x10, 0x10, 0x00, 0x10, 0x10,\
/*  32 */ 0x00, 0x00, 0x10, 0x00, 0x00, 0x02, 0x03, 0x02,\
/*  40 */ 0x02, 0x00, 0x00, 0x01, 0x01, 0x03, 0x03, 0x00,\
/*  48 */ 0x00, 0x00, 0x10, 0x10, 0x08, 0x00, 0x00, 0x00,\
/*  56 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x09,\
/*  64 */ 0x09, 0x09, 0x04, 0x09, 0x09, 0x09, 0x09, 0x26,\
/*  72 */ 0x26, 0x10, 0x10, 0x00, 0x03, 0x03, 0x0b, 0x0b,\
/*  80 */ 0x0b, 0x0b, 0x0b, 0x0b, 0x00, 0x26, 0x26, 0x26,\
/*  88 */ 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x00,\
/*  96 */ 0x12, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10,\
/* 104 */ 0x00, 0x01, 0x01, 0x01, 0x01, 0x04, 0x04, 0x00,\
/* 112 */ 0x10, 0x01, 0x01, 0x01, 0x01, 0x10, 0x00, 0x00,\
/* 120 */ 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\
/* 128 */ 0x06, 0x23, 0x0b, 0x01, 0x10, 0x10, 0x00, 0x01,\
/* 136 */ 0x04, 0x03, 0x03, 0x03, 0x03, 0x03, 0x00, 0x01,\
/* 144 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,\
/* 152 */ 0x00, 0x10, 0x10, 0x01, 0x00, 0x00,}

Definition at line 9928 of file sqlite3.c.

#define OPFLG_JUMP 0x0001 /* jump: P2 holds jmp target */

Definition at line 9922 of file sqlite3.c.

#define OPFLG_OUT2 0x0010 /* out2: P2 is an output */

Definition at line 9926 of file sqlite3.c.

#define OPFLG_OUT3 0x0020 /* out3: P3 is an output */

Definition at line 9927 of file sqlite3.c.

#define OpHelp ( X )

Definition at line 25093 of file sqlite3.c.

#define OptimizationDisabled	(	db,
		mask
	)	(((db)->dbOptFlags&(mask))!=0)

Definition at line 11171 of file sqlite3.c.

#define OptimizationEnabled	(	db,
		mask
	)	(((db)->dbOptFlags&(mask))==0)

Definition at line 11172 of file sqlite3.c.

#define OS_VXWORKS 0

Definition at line 123 of file sqlite3.c.

#define osAccess ((int(*)(const char*,int))aSyscall[2].pCurrent)

#define osClose ((int(*)(int))aSyscall[1].pCurrent)

#define osFallocate ((int(*)(int,off_t,off_t))aSyscall[15].pCurrent)

#define osFchmod ((int(*)(int,mode_t))aSyscall[14].pCurrent)

#define osFchown ((int(*)(int,uid_t,gid_t))aSyscall[20].pCurrent)

#define osFcntl ((int(*)(int,int,...))aSyscall[7].pCurrent)

#define osFstat ((int(*)(int,struct stat*))aSyscall[5].pCurrent)

#define osFtruncate ((int(*)(int,off_t))aSyscall[6].pCurrent)

#define osGetcwd ((char*(*)(char*,size_t))aSyscall[3].pCurrent)

#define osGetpagesize ((int(*)(void))aSyscall[24].pCurrent)

#define osGetpid ( X ) (pid_t)getpid()

Definition at line 25413 of file sqlite3.c.

#define osMkdir ((int(*)(const char*,mode_t))aSyscall[18].pCurrent)

#define osMmap ((void*(*)(void*,size_t,int,int,int,off_t))aSyscall[21].pCurrent)

#define osMremap ((void*(*)(void*,size_t,size_t,int,...))aSyscall[23].pCurrent)

#define osMunmap ((void*(*)(void*,size_t))aSyscall[22].pCurrent)

#define osOpen ((int(*)(const char*,int,int))aSyscall[0].pCurrent)

#define osOpenDirectory ((int(*)(const char*,int*))aSyscall[17].pCurrent)

#define osPread ((ssize_t(*)(int,void*,size_t,off_t))aSyscall[9].pCurrent)

#define osPread64 ((ssize_t(*)(int,void*,size_t,off_t))aSyscall[10].pCurrent)

#define osPwrite

Value:

((ssize_t(*)(int,const void*,size_t,off_t))\

aSyscall[12].pCurrent)

#define osPwrite64

Value:

((ssize_t(*)(int,const void*,size_t,off_t))\

aSyscall[13].pCurrent)

#define osRead ((ssize_t(*)(int,void*,size_t))aSyscall[8].pCurrent)

#define osRmdir ((int(*)(const char*))aSyscall[19].pCurrent)

#define osStat ((int(*)(const char*,struct stat*))aSyscall[4].pCurrent)

#define OSTRACE ( X )

Definition at line 25566 of file sqlite3.c.

#define osUnlink ((int(*)(const char*))aSyscall[16].pCurrent)

#define osWrite ((ssize_t(*)(int,const void*,size_t))aSyscall[11].pCurrent)

#define P4_ADVANCE (-19) /* P4 is a pointer to BtreeNext() or BtreePrev() */

Definition at line 9716 of file sqlite3.c.

#define P4_COLLSEQ (-4) /* P4 is a pointer to a CollSeq structure */

Definition at line 9704 of file sqlite3.c.

#define P4_DYNAMIC (-1) /* Pointer to a string obtained from sqliteMalloc() */

Definition at line 9702 of file sqlite3.c.

#define P4_FUNCDEF (-5) /* P4 is a pointer to a FuncDef structure */

Definition at line 9705 of file sqlite3.c.

#define P4_INT32 (-14) /* P4 is a 32-bit signed integer */

Definition at line 9713 of file sqlite3.c.

#define P4_INT64 (-13) /* P4 is a 64-bit signed integer */

Definition at line 9712 of file sqlite3.c.

#define P4_INTARRAY (-15) /* P4 is a vector of 32-bit integers */

Definition at line 9714 of file sqlite3.c.

#define P4_KEYINFO (-6) /* P4 is a pointer to a KeyInfo structure */

Definition at line 9706 of file sqlite3.c.

#define P4_MEM (-8) /* P4 is a pointer to a Mem* structure */

Definition at line 9707 of file sqlite3.c.

#define P4_MPRINTF (-11) /* P4 is a string obtained from sqlite3_mprintf() */

Definition at line 9710 of file sqlite3.c.

#define P4_NOTUSED 0 /* The P4 parameter is not used */

Definition at line 9701 of file sqlite3.c.

#define P4_REAL (-12) /* P4 is a 64-bit floating point value */

Definition at line 9711 of file sqlite3.c.

#define P4_STATIC (-2) /* Pointer to a static string */

Definition at line 9703 of file sqlite3.c.

#define P4_SUBPROGRAM (-18) /* P4 is a pointer to a SubProgram structure */

Definition at line 9715 of file sqlite3.c.

#define P4_TRANSIENT 0 /* P4 is a pointer to a transient string */

Definition at line 9708 of file sqlite3.c.

#define P4_VTAB (-10) /* P4 is a pointer to an sqlite3_vtab structure */

Definition at line 9709 of file sqlite3.c.

#define P5_ConstraintCheck 3

Definition at line 9721 of file sqlite3.c.

#define P5_ConstraintFK 4

Definition at line 9722 of file sqlite3.c.

#define P5_ConstraintNotNull 1

Definition at line 9719 of file sqlite3.c.

#define P5_ConstraintUnique 2

Definition at line 9720 of file sqlite3.c.

#define PAGER_CACHESPILL 0x10 /* PRAGMA cache_spill=ON */

Definition at line 10184 of file sqlite3.c.

#define PAGER_CKPT_FULLFSYNC 0x08 /* PRAGMA checkpoint_fullfsync=ON */

Definition at line 10183 of file sqlite3.c.

#define pager_datahash	(	X,
		Y
	)	0

Definition at line 42871 of file sqlite3.c.

#define PAGER_ERROR 6

Definition at line 42020 of file sqlite3.c.

#define PAGER_FLAGS_MASK 0x1c /* All above except SYNCHRONOUS */

Definition at line 10185 of file sqlite3.c.

#define PAGER_FULLFSYNC 0x04 /* PRAGMA fullfsync=ON */

Definition at line 10182 of file sqlite3.c.

#define PAGER_GET_NOCONTENT 0x01 /* Do not load data from disk */

Definition at line 10172 of file sqlite3.c.

#define PAGER_GET_READONLY 0x02 /* Read-only page is acceptable */

Definition at line 10173 of file sqlite3.c.

#define PAGER_INCR ( v )

Definition at line 42391 of file sqlite3.c.

#define PAGER_JOURNALMODE_DELETE 0 /* Commit by deleting journal file */

Definition at line 10162 of file sqlite3.c.

#define PAGER_JOURNALMODE_MEMORY 4 /* In-memory journal file */

Definition at line 10166 of file sqlite3.c.

#define PAGER_JOURNALMODE_OFF 2 /* Journal omitted. */

Definition at line 10164 of file sqlite3.c.

#define PAGER_JOURNALMODE_PERSIST 1 /* Commit by zeroing journal header */

Definition at line 10163 of file sqlite3.c.

#define PAGER_JOURNALMODE_QUERY (-1) /* Query the value of journalmode */

Definition at line 10161 of file sqlite3.c.

#define PAGER_JOURNALMODE_TRUNCATE 3 /* Commit by truncating journal */

Definition at line 10165 of file sqlite3.c.

#define PAGER_JOURNALMODE_WAL 5 /* Use write-ahead logging */

Definition at line 10167 of file sqlite3.c.

#define PAGER_LOCKINGMODE_EXCLUSIVE 1

Definition at line 10156 of file sqlite3.c.

#define PAGER_LOCKINGMODE_NORMAL 0

Definition at line 10155 of file sqlite3.c.

#define PAGER_LOCKINGMODE_QUERY -1

Definition at line 10154 of file sqlite3.c.

#define PAGER_MAX_PGNO 2147483647

Definition at line 42460 of file sqlite3.c.

#define PAGER_MEMORY 0x0002 /* In-memory database */

Definition at line 10149 of file sqlite3.c.

#define PAGER_MJ_PGNO ( x ) ((Pgno)((PENDING_BYTE/((x)->pageSize))+1))

Definition at line 10141 of file sqlite3.c.

#define PAGER_OMIT_JOURNAL 0x0001 /* Do not use a rollback journal */

Definition at line 10148 of file sqlite3.c.

#define PAGER_OPEN 0

Definition at line 42014 of file sqlite3.c.

#define pager_pagehash ( X ) 0

Definition at line 42872 of file sqlite3.c.

#define PAGER_READER 1

Definition at line 42015 of file sqlite3.c.

#define pager_set_pagehash ( X )

Definition at line 42873 of file sqlite3.c.

#define PAGER_STAT_HIT 0

Definition at line 42376 of file sqlite3.c.

#define PAGER_STAT_MISS 1

Definition at line 42377 of file sqlite3.c.

#define PAGER_STAT_WRITE 2

Definition at line 42378 of file sqlite3.c.

#define PAGER_SYNCHRONOUS_FULL 0x03 /* PRAGMA synchronous=FULL */

Definition at line 10180 of file sqlite3.c.

#define PAGER_SYNCHRONOUS_MASK 0x03 /* Mask for three values above */

Definition at line 10181 of file sqlite3.c.

#define PAGER_SYNCHRONOUS_NORMAL 0x02 /* PRAGMA synchronous=NORMAL */

Definition at line 10179 of file sqlite3.c.

#define PAGER_SYNCHRONOUS_OFF 0x01 /* PRAGMA synchronous=OFF */

Definition at line 10178 of file sqlite3.c.

#define PAGER_WRITER_CACHEMOD 3

Definition at line 42017 of file sqlite3.c.

#define PAGER_WRITER_DBMOD 4

Definition at line 42018 of file sqlite3.c.

#define PAGER_WRITER_FINISHED 5

Definition at line 42019 of file sqlite3.c.

#define PAGER_WRITER_LOCKED 2

Definition at line 42016 of file sqlite3.c.

#define PAGERID ( p ) ((int)(p->fd))

Definition at line 41794 of file sqlite3.c.

#define pagerReportSize ( X ) /* No-op if we do not support a codec */

Definition at line 43776 of file sqlite3.c.

#define PAGERTRACE ( X )

Definition at line 41783 of file sqlite3.c.

#define PARTLY_WITHIN 1 /* Object partially overlaps query region */

Definition at line 8029 of file sqlite3.c.

#define pcache1 (GLOBAL(struct PCacheGlobal, pcache1_g))

Definition at line 40104 of file sqlite3.c.

#define pcache1EnterMutex ( X ) sqlite3_mutex_enter((X)->mutex)

Definition at line 40109 of file sqlite3.c.

#define pcache1LeaveMutex ( X ) sqlite3_mutex_leave((X)->mutex)

Definition at line 40110 of file sqlite3.c.

#define PCACHE_DIRTYLIST_ADD 2 /* Add pPage to the dirty list */

Definition at line 39324 of file sqlite3.c.

#define PCACHE_DIRTYLIST_FRONT 3 /* Move pPage to the front of the list */

Definition at line 39325 of file sqlite3.c.

#define PCACHE_DIRTYLIST_REMOVE 1 /* Remove pPage from dirty list */

Definition at line 39323 of file sqlite3.c.

#define PENDING_BYTE sqlite3PendingByte

Definition at line 10689 of file sqlite3.c.

#define PENDING_BYTE_PAGE ( pBt ) PAGER_MJ_PGNO(pBt)

Definition at line 52684 of file sqlite3.c.

#define PENDING_LOCK 3

Definition at line 10628 of file sqlite3.c.

#define PGHDR_DIRTY 0x002 /* Page has changed */

Definition at line 10355 of file sqlite3.c.

#define PGHDR_DONT_WRITE 0x020 /* Do not write content to disk */

Definition at line 10360 of file sqlite3.c.

#define PGHDR_MMAP 0x040 /* This is an mmap page object */

Definition at line 10362 of file sqlite3.c.

#define PGHDR_NEED_READ 0x008 /* Content is unread */

Definition at line 10358 of file sqlite3.c.

#define PGHDR_NEED_SYNC

Value:

0x004 /* Fsync the rollback journal before

** writing this page to the database */

Definition at line 10356 of file sqlite3.c.

#define PGHDR_REUSE_UNLIKELY 0x010 /* A hint that reuse is unlikely */

Definition at line 10359 of file sqlite3.c.

#define PragFlag_NeedSchema 0x01

Definition at line 103216 of file sqlite3.c.

#define PragFlag_ReadOnly 0x02

Definition at line 103217 of file sqlite3.c.

#define PragTyp_ACTIVATE_EXTENSIONS 36

Definition at line 103210 of file sqlite3.c.

#define PragTyp_AUTO_VACUUM 1

Definition at line 103175 of file sqlite3.c.

#define PragTyp_BUSY_TIMEOUT 3

Definition at line 103177 of file sqlite3.c.

#define PragTyp_CACHE_SIZE 4

Definition at line 103178 of file sqlite3.c.

#define PragTyp_CASE_SENSITIVE_LIKE 5

Definition at line 103179 of file sqlite3.c.

#define PragTyp_COLLATION_LIST 6

Definition at line 103180 of file sqlite3.c.

#define PragTyp_COMPILE_OPTIONS 7

Definition at line 103181 of file sqlite3.c.

#define PragTyp_DATA_STORE_DIRECTORY 8

Definition at line 103182 of file sqlite3.c.

#define PragTyp_DATABASE_LIST 9

Definition at line 103183 of file sqlite3.c.

#define PragTyp_DEFAULT_CACHE_SIZE 10

Definition at line 103184 of file sqlite3.c.

#define PragTyp_ENCODING 11

Definition at line 103185 of file sqlite3.c.

#define PragTyp_FLAG 2

Definition at line 103176 of file sqlite3.c.

#define PragTyp_FOREIGN_KEY_CHECK 12

Definition at line 103186 of file sqlite3.c.

#define PragTyp_FOREIGN_KEY_LIST 13

Definition at line 103187 of file sqlite3.c.

#define PragTyp_HEADER_VALUE 0

Definition at line 103174 of file sqlite3.c.

#define PragTyp_HEXKEY 37

Definition at line 103211 of file sqlite3.c.

#define PragTyp_INCREMENTAL_VACUUM 14

Definition at line 103188 of file sqlite3.c.

#define PragTyp_INDEX_INFO 15

Definition at line 103189 of file sqlite3.c.

#define PragTyp_INDEX_LIST 16

Definition at line 103190 of file sqlite3.c.

#define PragTyp_INTEGRITY_CHECK 17

Definition at line 103191 of file sqlite3.c.

#define PragTyp_JOURNAL_MODE 18

Definition at line 103192 of file sqlite3.c.

#define PragTyp_JOURNAL_SIZE_LIMIT 19

Definition at line 103193 of file sqlite3.c.

#define PragTyp_KEY 38

Definition at line 103212 of file sqlite3.c.

#define PragTyp_LOCK_PROXY_FILE 20

Definition at line 103194 of file sqlite3.c.

#define PragTyp_LOCK_STATUS 40

Definition at line 103214 of file sqlite3.c.

#define PragTyp_LOCKING_MODE 21

Definition at line 103195 of file sqlite3.c.

#define PragTyp_MMAP_SIZE 23

Definition at line 103197 of file sqlite3.c.

#define PragTyp_PAGE_COUNT 22

Definition at line 103196 of file sqlite3.c.

#define PragTyp_PAGE_SIZE 24

Definition at line 103198 of file sqlite3.c.

#define PragTyp_PARSER_TRACE 41

Definition at line 103215 of file sqlite3.c.

#define PragTyp_REKEY 39

Definition at line 103213 of file sqlite3.c.

#define PragTyp_SECURE_DELETE 25

Definition at line 103199 of file sqlite3.c.

#define PragTyp_SHRINK_MEMORY 26

Definition at line 103200 of file sqlite3.c.

#define PragTyp_SOFT_HEAP_LIMIT 27

Definition at line 103201 of file sqlite3.c.

#define PragTyp_STATS 28

Definition at line 103202 of file sqlite3.c.

#define PragTyp_SYNCHRONOUS 29

Definition at line 103203 of file sqlite3.c.

#define PragTyp_TABLE_INFO 30

Definition at line 103204 of file sqlite3.c.

#define PragTyp_TEMP_STORE 31

Definition at line 103205 of file sqlite3.c.

#define PragTyp_TEMP_STORE_DIRECTORY 32

Definition at line 103206 of file sqlite3.c.

#define PragTyp_THREADS 33

Definition at line 103207 of file sqlite3.c.

#define PragTyp_WAL_AUTOCHECKPOINT 34

Definition at line 103208 of file sqlite3.c.

#define PragTyp_WAL_CHECKPOINT 35

Definition at line 103209 of file sqlite3.c.

#define PTF_INTKEY 0x01

Definition at line 52367 of file sqlite3.c.

#define PTF_LEAF 0x08

Definition at line 52370 of file sqlite3.c.

#define PTF_LEAFDATA 0x04

Definition at line 52369 of file sqlite3.c.

#define PTF_ZERODATA 0x02

Definition at line 52368 of file sqlite3.c.

#define PTRMAP_BTREE 5

Definition at line 52740 of file sqlite3.c.

#define PTRMAP_FREEPAGE 2

Definition at line 52737 of file sqlite3.c.

#define PTRMAP_ISPAGE	(	pBt,
		pgno
	)	(PTRMAP_PAGENO((pBt),(pgno))==(pgno))

Definition at line 52703 of file sqlite3.c.

#define PTRMAP_OVERFLOW1 3

Definition at line 52738 of file sqlite3.c.

#define PTRMAP_OVERFLOW2 4

Definition at line 52739 of file sqlite3.c.

#define PTRMAP_PAGENO	(	pBt,
		pgno
	)	ptrmapPageno(pBt, pgno)

Definition at line 52701 of file sqlite3.c.

#define PTRMAP_PTROFFSET	(	pgptrmap,
		pgno
	)	(5*(pgno-pgptrmap-1))

Definition at line 52702 of file sqlite3.c.

#define PTRMAP_ROOTPAGE 1

Definition at line 52736 of file sqlite3.c.

#define put2byte	(	p,
		v
	)	((p)[0] = (u8)((v)>>8), (p)[1] = (u8)(v))

Definition at line 52792 of file sqlite3.c.

#define put32bits	(	A,
		B
	)	sqlite3Put4byte((u8*)A,B)

Definition at line 42730 of file sqlite3.c.

#define put4byte sqlite3Put4byte

Definition at line 52794 of file sqlite3.c.

#define putVarint sqlite3PutVarint

Definition at line 13403 of file sqlite3.c.

#define putVarint32	(	A,
		B
	)

Value:

(u8)(((u32)(B)<(u32)0x80)?(*(A)=(unsigned char)(B)),1:\

sqlite3PutVarint((A),(B)))

u8

UINT8_TYPE u8

Definition: sqlite3.c:8959

u32

UINT32_TYPE u32

Definition: sqlite3.c:8956

sqlite3PutVarint

SQLITE_PRIVATE int sqlite3PutVarint(unsigned char *, u64)

Definition: sqlite3.c:24185

Definition at line 13399 of file sqlite3.c.

#define READ_LOCK 1

Definition at line 52435 of file sqlite3.c.

#define READ_UTF16BE	(	zIn,
		TERM,
		c
	)

Value:

{                                   \
  c = ((*zIn++)<<8);                                                  \
  c += (*zIn++);                                                      \
  if( c>=0xD800 && c<0xE000 && TERM ){                                \
    int c2 = ((*zIn++)<<8);                                           \
    c2 += (*zIn++);                                                   \
    c = (c2&0x03FF) + ((c&0x003F)<<10) + (((c&0x03C0)+0x0040)<<10);   \
  }                                                                   \
}

Definition at line 23025 of file sqlite3.c.

#define READ_UTF16LE	(	zIn,
		TERM,
		c
	)

Value:

{                                   \
  c = (*zIn++);                                                       \
  c += ((*zIn++)<<8);                                                 \
  if( c>=0xD800 && c<0xE000 && TERM ){                                \
    int c2 = (*zIn++);                                                \
    c2 += ((*zIn++)<<8);                                              \
    c = (c2&0x03FF) + ((c&0x003F)<<10) + (((c&0x03C0)+0x0040)<<10);   \
  }                                                                   \
}

Definition at line 23015 of file sqlite3.c.

#define READ_UTF8	(	zIn,
		zTerm,
		c
	)

Value:

c = *(zIn++);                                            \
  if( c>=0xc0 ){                                           \
    c = sqlite3Utf8Trans1[c-0xc0];                         \
    while( zIn!=zTerm && (*zIn & 0xc0)==0x80 ){            \
      c = (c<<6) + (0x3f & *(zIn++));                      \
    }                                                      \
    if( c<0x80                                             \
        || (c&0xFFFFF800)==0xD800                          \
        || (c&0xFFFFFFFE)==0xFFFE ){  c = 0xFFFD; }        \
  }

Definition at line 23062 of file sqlite3.c.

#define READMARK_NOT_USED 0xffffffff

Definition at line 49301 of file sqlite3.c.

#define REGISTER_TRACE	(	R,
		M
	)

Definition at line 71258 of file sqlite3.c.

#define RESERVED_BYTE (PENDING_BYTE+1)

Definition at line 10691 of file sqlite3.c.

#define RESERVED_LOCK 2

Definition at line 10627 of file sqlite3.c.

#define restoreCursorPosition ( p )

Value:

(p->eState>=CURSOR_REQUIRESEEK ? \
         btreeRestoreCursorPosition(p) : \
         SQLITE_OK)

Definition at line 53856 of file sqlite3.c.

#define ROUND8 ( x ) (((x)+7)&~7)

Definition at line 9070 of file sqlite3.c.

#define ROUNDDOWN8 ( x ) ((x)&~7)

Definition at line 9075 of file sqlite3.c.

#define ROWSET_ALLOCATION_SIZE 1024

Definition at line 41082 of file sqlite3.c.

#define ROWSET_ENTRY_PER_CHUNK ((ROWSET_ALLOCATION_SIZE-8)/sizeof(struct RowSetEntry))

Definition at line 41087 of file sqlite3.c.

#define ROWSET_NEXT 0x02 /* True if sqlite3RowSetNext() has been called */

Definition at line 41136 of file sqlite3.c.

#define ROWSET_SORTED 0x01 /* True if RowSet.pEntry is sorted */

Definition at line 41135 of file sqlite3.c.

#define SAVE_SZ (sizeof(Parse) - offsetof(Parse,nVar))

#define SAVEPOINT_BEGIN 0

Definition at line 11320 of file sqlite3.c.

#define SAVEPOINT_RELEASE 1

Definition at line 11321 of file sqlite3.c.

#define SAVEPOINT_ROLLBACK 2

Definition at line 11322 of file sqlite3.c.

#define SCHEMA_ENC ( db ) ((db)->aDb[0].pSchema->enc)

Definition at line 11109 of file sqlite3.c.

#define SCHEMA_TABLE ( x ) ((!OMIT_TEMPDB)&&(x==1)?TEMP_MASTER_NAME:MASTER_NAME)

Definition at line 9192 of file sqlite3.c.

#define SELECTTRACE	(	K,
		P,
		S,
		X
	)

Definition at line 106503 of file sqlite3.c.

#define SELECTTRACE_ENABLED 0

Definition at line 9157 of file sqlite3.c.

#define SET_FULLSYNC	(	x,
		y
	)

Definition at line 10573 of file sqlite3.c.

#define SETBIT	(	V,
		I
	)	V[I>>3] \|= (1<<(I&7))

Definition at line 39176 of file sqlite3.c.

#define SF_Aggregate 0x0004 /* Contains aggregate functions */

Definition at line 12305 of file sqlite3.c.

#define SF_Compound 0x0040 /* Part of a compound query */

Definition at line 12309 of file sqlite3.c.

#define SF_Converted 0x2000 /* By convertCompoundSelectToSubquery() */

Definition at line 12316 of file sqlite3.c.

#define SF_Distinct 0x0001 /* Output should be DISTINCT */

Definition at line 12303 of file sqlite3.c.

#define SF_Expanded 0x0010 /* sqlite3SelectExpand() called on this */

Definition at line 12307 of file sqlite3.c.

#define SF_HasTypeInfo 0x0020 /* FROM subqueries have Table metadata */

Definition at line 12308 of file sqlite3.c.

#define SF_MaybeConvert 0x0400 /* Need convertCompoundSelectToSubquery() */

Definition at line 12313 of file sqlite3.c.

#define SF_MinMaxAgg 0x1000 /* Aggregate containing min() or max() */

Definition at line 12315 of file sqlite3.c.

#define SF_MultiValue 0x0100 /* Single VALUES term with multiple rows */

Definition at line 12311 of file sqlite3.c.

#define SF_NestedFrom 0x0200 /* Part of a parenthesized FROM clause */

Definition at line 12312 of file sqlite3.c.

#define SF_Recursive 0x0800 /* The recursive part of a recursive CTE */

Definition at line 12314 of file sqlite3.c.

#define SF_Resolved 0x0002 /* Identifiers have been resolved */

Definition at line 12304 of file sqlite3.c.

#define SF_UsesEphemeral 0x0008 /* Uses the OpenEphemeral opcode */

Definition at line 12306 of file sqlite3.c.

#define SF_Values 0x0080 /* Synthesized from VALUES clause */

Definition at line 12310 of file sqlite3.c.

#define SHARED_FIRST (PENDING_BYTE+2)

Definition at line 10692 of file sqlite3.c.

#define SHARED_LOCK 1

Definition at line 10626 of file sqlite3.c.

#define SHARED_SIZE 510

Definition at line 10693 of file sqlite3.c.

#define SimulateDiskfullError ( A )

Definition at line 25718 of file sqlite3.c.

#define SimulateIOError ( A )

Definition at line 25717 of file sqlite3.c.

#define SimulateIOErrorBenign ( X )

Definition at line 25716 of file sqlite3.c.

#define SLOT_2_0 0x001fc07f

Definition at line 24207 of file sqlite3.c.

#define SLOT_4_2_0 0xf01fc07f

Definition at line 24208 of file sqlite3.c.

#define SMALLEST_INT64 (((i64)-1) - LARGEST_INT64)

Definition at line 9064 of file sqlite3.c.

#define SORTER_MAX_MERGE_COUNT 16

Definition at line 78389 of file sqlite3.c.

#define SORTER_TYPE_INTEGER 0x01

Definition at line 78267 of file sqlite3.c.

#define SORTER_TYPE_TEXT 0x02

Definition at line 78268 of file sqlite3.c.

#define SORTFLAG_UseSorter 0x01 /* Use SorterOpen instead of OpenEphemeral */

Definition at line 106534 of file sqlite3.c.

#define SPILLFLAG_NOSYNC 0x04 /* Spill is ok, but do not sync */

Definition at line 42124 of file sqlite3.c.

#define SPILLFLAG_OFF 0x01 /* Never spill cache. Set via pragma */

Definition at line 42122 of file sqlite3.c.

#define SPILLFLAG_ROLLBACK 0x02 /* Current rolling back, so do not spill */

Definition at line 42123 of file sqlite3.c.

#define sqlite3_column_database_name 0

Definition at line 102395 of file sqlite3.c.

#define sqlite3_column_database_name16 0

Definition at line 102396 of file sqlite3.c.

#define sqlite3_column_origin_name 0

Definition at line 102399 of file sqlite3.c.

#define sqlite3_column_origin_name16 0

Definition at line 102400 of file sqlite3.c.

#define sqlite3_column_table_name 0

Definition at line 102397 of file sqlite3.c.

#define sqlite3_column_table_name16 0

Definition at line 102398 of file sqlite3.c.

#define SQLITE3_MUTEX_INITIALIZER { PTHREAD_MUTEX_INITIALIZER }

Definition at line 19531 of file sqlite3.c.

#define SQLITE3_TEXT 3

Definition at line 4096 of file sqlite3.c.

#define sqlite3ConnectionBlocked	(	x,
		y
	)

Definition at line 13714 of file sqlite3.c.

#define sqlite3ConnectionClosed ( x )

Definition at line 13716 of file sqlite3.c.

#define sqlite3ConnectionUnlocked ( x )

Definition at line 13715 of file sqlite3.c.

#define sqlite3FileSuffix3	(	X,
		Y
	)

Definition at line 13441 of file sqlite3.c.

#define sqlite3GlobalConfig sqlite3Config

Definition at line 9238 of file sqlite3.c.

#define sqlite3Isalnum ( x ) (sqlite3CtypeMap[(unsigned char)(x)]&0x06)

Definition at line 12961 of file sqlite3.c.

#define sqlite3Isalpha ( x ) (sqlite3CtypeMap[(unsigned char)(x)]&0x02)

Definition at line 12962 of file sqlite3.c.

#define sqlite3Isdigit ( x ) (sqlite3CtypeMap[(unsigned char)(x)]&0x04)

Definition at line 12963 of file sqlite3.c.

#define sqlite3IsNumericAffinity ( X ) ((X)>=SQLITE_AFF_NUMERIC)

Definition at line 11401 of file sqlite3.c.

#define sqlite3Isspace ( x ) (sqlite3CtypeMap[(unsigned char)(x)]&0x01)

Definition at line 12960 of file sqlite3.c.

#define sqlite3Isxdigit ( x ) (sqlite3CtypeMap[(unsigned char)(x)]&0x08)

Definition at line 12964 of file sqlite3.c.

#define sqlite3JournalExists ( p ) 1

Definition at line 13690 of file sqlite3.c.

#define sqlite3JournalSize ( pVfs ) ((pVfs)->szOsFile)

Definition at line 13689 of file sqlite3.c.

#define sqlite3MemdebugHasType	(	X,
		Y
	)	1

Definition at line 13771 of file sqlite3.c.

#define sqlite3MemdebugNoType	(	X,
		Y
	)	1

Definition at line 13772 of file sqlite3.c.

#define sqlite3MemdebugSetType	(	X,
		Y
	)	/* no-op */

Definition at line 13770 of file sqlite3.c.

#define sqlite3PagerGet	(	A,
		B,
		C
	)	sqlite3PagerAcquire(A,B,C,0)

Definition at line 10223 of file sqlite3.c.

#define sqlite3ParserARG_FETCH Parse *pParse = yypParser->pParse

Definition at line 123470 of file sqlite3.c.

#define sqlite3ParserARG_PDECL ,Parse *pParse

Definition at line 123469 of file sqlite3.c.

#define sqlite3ParserARG_SDECL Parse *pParse;

Definition at line 123468 of file sqlite3.c.

#define sqlite3ParserARG_STORE yypParser->pParse = pParse

Definition at line 123471 of file sqlite3.c.

#define sqlite3ParserTOKENTYPE Token

Definition at line 123445 of file sqlite3.c.

#define sqlite3ParseToplevel ( p ) ((p)->pToplevel ? (p)->pToplevel : (p))

Definition at line 13333 of file sqlite3.c.

#define sqlite3SelectSetName	(	A,
		B
	)

Definition at line 13297 of file sqlite3.c.

#define sqlite3StackAllocRaw	(	D,
		N
	)	sqlite3DbMallocRaw(D,N)

Definition at line 13019 of file sqlite3.c.

#define sqlite3StackAllocZero	(	D,
		N
	)	sqlite3DbMallocZero(D,N)

Definition at line 13020 of file sqlite3.c.

#define sqlite3StackFree	(	D,
		P
	)	sqlite3DbFree(D,P)

Definition at line 13021 of file sqlite3.c.

#define sqlite3StrICmp sqlite3_stricmp

Definition at line 12980 of file sqlite3.c.

#define sqlite3StrNICmp sqlite3_strnicmp

Definition at line 12982 of file sqlite3.c.

#define sqlite3Tolower ( x ) (sqlite3UpperToLower[(unsigned char)(x)])

Definition at line 12965 of file sqlite3.c.

#define sqlite3Toupper ( x ) ((x)&~(sqlite3CtypeMap[(unsigned char)(x)]&0x20))

Definition at line 12959 of file sqlite3.c.

#define sqlite3VdbeIOTraceSql ( X )

Definition at line 13734 of file sqlite3.c.

#define sqlite3VdbeScanStatus	(	a,
		b,
		c,
		d,
		e
	)

Definition at line 10080 of file sqlite3.c.

#define sqlite3VtabInSync ( db ) ((db)->nVTrans>0 && (db)->aVTrans==0)

Definition at line 13583 of file sqlite3.c.

#define SQLITE_ABORT 4 /* Callback routine requested an abort */

Definition at line 616 of file sqlite3.c.

#define SQLITE_ABORT_ROLLBACK (SQLITE_ABORT | (2<<8))

Definition at line 699 of file sqlite3.c.

#define SQLITE_ACCESS_EXISTS 0

Definition at line 1435 of file sqlite3.c.

#define SQLITE_ACCESS_READ 2 /* Unused */

Definition at line 1437 of file sqlite3.c.

#define SQLITE_ACCESS_READWRITE 1 /* Used by PRAGMA temp_store_directory */

Definition at line 1436 of file sqlite3.c.

#define SQLITE_AFF_INTEGER 'D'

Definition at line 11398 of file sqlite3.c.

#define SQLITE_AFF_MASK 0x47

Definition at line 11407 of file sqlite3.c.

#define SQLITE_AFF_NONE 'A'

Definition at line 11395 of file sqlite3.c.

#define SQLITE_AFF_NUMERIC 'C'

Definition at line 11397 of file sqlite3.c.

#define SQLITE_AFF_REAL 'E'

Definition at line 11399 of file sqlite3.c.

#define SQLITE_AFF_TEXT 'B'

Definition at line 11396 of file sqlite3.c.

#define SQLITE_AllOpts 0xffff /* All optimizations */

Definition at line 11165 of file sqlite3.c.

#define SQLITE_ALLOW_COVERING_INDEX_SCAN 1

Definition at line 13941 of file sqlite3.c.

#define SQLITE_ALTER_TABLE 26 /* Database Name Table Name */

Definition at line 2868 of file sqlite3.c.

#define SQLITE_AMALGAMATION 1

Definition at line 21 of file sqlite3.c.

#define SQLITE_ANALYZE 28 /* Table Name NULL */

Definition at line 2870 of file sqlite3.c.

#define SQLITE_ANY 5 /* Deprecated */

Definition at line 4467 of file sqlite3.c.

#define SQLITE_API

Definition at line 259 of file sqlite3.c.

#define SQLITE_ASCII 1

Definition at line 8906 of file sqlite3.c.

#define SQLITE_ATTACH 24 /* Filename NULL */

Definition at line 2866 of file sqlite3.c.

#define SQLITE_AUTH 23 /* Authorization denied */

Definition at line 635 of file sqlite3.c.

#define SQLITE_AUTH_USER (SQLITE_AUTH | (1<<8))

Definition at line 713 of file sqlite3.c.

#define SQLITE_AutoIndex 0x00100000 /* Enable automatic indexes */

Definition at line 11138 of file sqlite3.c.

#define SQLITE_BIG_DBL (1e99)

Definition at line 8817 of file sqlite3.c.

#define SQLITE_BIGENDIAN (*(char *)(&sqlite3one)==0)

Definition at line 9053 of file sqlite3.c.

#define SQLITE_BLOB 4

Definition at line 4089 of file sqlite3.c.

#define SQLITE_BUSY 5 /* The database file is locked */

Definition at line 617 of file sqlite3.c.

#define SQLITE_BUSY_RECOVERY (SQLITE_BUSY | (1<<8))

Definition at line 688 of file sqlite3.c.

#define SQLITE_BUSY_SNAPSHOT (SQLITE_BUSY | (2<<8))

Definition at line 689 of file sqlite3.c.

#define SQLITE_BYTEORDER 0 /* 0 means "unknown at compile-time" */

Definition at line 9052 of file sqlite3.c.

#define SQLITE_CacheSpill 0x00000010 /* OK to spill pager cache */

Definition at line 11119 of file sqlite3.c.

#define SQLITE_CANTOPEN 14 /* Unable to open the database file */

Definition at line 626 of file sqlite3.c.

#define SQLITE_CANTOPEN_BKPT sqlite3CantopenError(__LINE__)

Definition at line 12932 of file sqlite3.c.

#define SQLITE_CANTOPEN_CONVPATH (SQLITE_CANTOPEN | (4<<8))

Definition at line 693 of file sqlite3.c.

#define SQLITE_CANTOPEN_FULLPATH (SQLITE_CANTOPEN | (3<<8))

Definition at line 692 of file sqlite3.c.

#define SQLITE_CANTOPEN_ISDIR (SQLITE_CANTOPEN | (2<<8))

Definition at line 691 of file sqlite3.c.

#define SQLITE_CANTOPEN_NOTEMPDIR (SQLITE_CANTOPEN | (1<<8))

Definition at line 690 of file sqlite3.c.

#define SQLITE_CDECL

Definition at line 262 of file sqlite3.c.

#define SQLITE_CHECKPOINT_FULL 1 /* Wait for writers, then checkpoint */

Definition at line 7716 of file sqlite3.c.

#define SQLITE_CHECKPOINT_PASSIVE 0 /* Do as much as possible w/o blocking */

Definition at line 7715 of file sqlite3.c.

#define SQLITE_CHECKPOINT_RESTART 2 /* Like FULL but wait for for readers */

Definition at line 7717 of file sqlite3.c.

#define SQLITE_CHECKPOINT_TRUNCATE 3 /* Like RESTART but also truncate WAL */

Definition at line 7718 of file sqlite3.c.

#define SQLITE_CkptFullFSync 0x00000008 /* Use full fsync for checkpoint */

Definition at line 11118 of file sqlite3.c.

#define SQLITE_ColumnCache 0x0002 /* Column cache */

Definition at line 11154 of file sqlite3.c.

#define SQLITE_CONFIG_COVERING_INDEX_SCAN 20 /* int */

Definition at line 2016 of file sqlite3.c.

#define SQLITE_CONFIG_GETMALLOC 5 /* sqlite3_mem_methods* */

Definition at line 2001 of file sqlite3.c.

#define SQLITE_CONFIG_GETMUTEX 11 /* sqlite3_mutex_methods* */

Definition at line 2007 of file sqlite3.c.

#define SQLITE_CONFIG_GETPCACHE 15 /* no-op */

Definition at line 2011 of file sqlite3.c.

#define SQLITE_CONFIG_GETPCACHE2 19 /* sqlite3_pcache_methods2* */

Definition at line 2015 of file sqlite3.c.

#define SQLITE_CONFIG_HEAP 8 /* void*, int nByte, int min */

Definition at line 2004 of file sqlite3.c.

#define SQLITE_CONFIG_LOG 16 /* xFunc, void* */

Definition at line 2012 of file sqlite3.c.

#define SQLITE_CONFIG_LOOKASIDE 13 /* int int */

Definition at line 2009 of file sqlite3.c.

#define SQLITE_CONFIG_MALLOC 4 /* sqlite3_mem_methods* */

Definition at line 2000 of file sqlite3.c.

#define SQLITE_CONFIG_MEMSTATUS 9 /* boolean */

Definition at line 2005 of file sqlite3.c.

#define SQLITE_CONFIG_MMAP_SIZE 22 /* sqlite3_int64, sqlite3_int64 */

Definition at line 2018 of file sqlite3.c.

#define SQLITE_CONFIG_MULTITHREAD 2 /* nil */

Definition at line 1998 of file sqlite3.c.

#define SQLITE_CONFIG_MUTEX 10 /* sqlite3_mutex_methods* */

Definition at line 2006 of file sqlite3.c.

#define SQLITE_CONFIG_PAGECACHE 7 /* void*, int sz, int N */

Definition at line 2003 of file sqlite3.c.

#define SQLITE_CONFIG_PCACHE 14 /* no-op */

Definition at line 2010 of file sqlite3.c.

#define SQLITE_CONFIG_PCACHE2 18 /* sqlite3_pcache_methods2* */

Definition at line 2014 of file sqlite3.c.

#define SQLITE_CONFIG_PCACHE_HDRSZ 24 /* int *psz */

Definition at line 2020 of file sqlite3.c.

#define SQLITE_CONFIG_PMASZ 25 /* unsigned int szPma */

Definition at line 2021 of file sqlite3.c.

#define SQLITE_CONFIG_SCRATCH 6 /* void*, int sz, int N */

Definition at line 2002 of file sqlite3.c.

#define SQLITE_CONFIG_SERIALIZED 3 /* nil */

Definition at line 1999 of file sqlite3.c.

#define SQLITE_CONFIG_SINGLETHREAD 1 /* nil */

Definition at line 1997 of file sqlite3.c.

#define SQLITE_CONFIG_SQLLOG 21 /* xSqllog, void* */

Definition at line 2017 of file sqlite3.c.

#define SQLITE_CONFIG_URI 17 /* int */

Definition at line 2013 of file sqlite3.c.

#define SQLITE_CONFIG_WIN32_HEAPSIZE 23 /* int nByte */

Definition at line 2019 of file sqlite3.c.

#define SQLITE_CONSTRAINT 19 /* Abort due to constraint violation */

Definition at line 631 of file sqlite3.c.

#define SQLITE_CONSTRAINT_CHECK (SQLITE_CONSTRAINT | (1<<8))

Definition at line 700 of file sqlite3.c.

#define SQLITE_CONSTRAINT_COMMITHOOK (SQLITE_CONSTRAINT | (2<<8))

Definition at line 701 of file sqlite3.c.

#define SQLITE_CONSTRAINT_FOREIGNKEY (SQLITE_CONSTRAINT | (3<<8))

Definition at line 702 of file sqlite3.c.

#define SQLITE_CONSTRAINT_FUNCTION (SQLITE_CONSTRAINT | (4<<8))

Definition at line 703 of file sqlite3.c.

#define SQLITE_CONSTRAINT_NOTNULL (SQLITE_CONSTRAINT | (5<<8))

Definition at line 704 of file sqlite3.c.

#define SQLITE_CONSTRAINT_PRIMARYKEY (SQLITE_CONSTRAINT | (6<<8))

Definition at line 705 of file sqlite3.c.

#define SQLITE_CONSTRAINT_ROWID (SQLITE_CONSTRAINT |(10<<8))

Definition at line 709 of file sqlite3.c.

#define SQLITE_CONSTRAINT_TRIGGER (SQLITE_CONSTRAINT | (7<<8))

Definition at line 706 of file sqlite3.c.

#define SQLITE_CONSTRAINT_UNIQUE (SQLITE_CONSTRAINT | (8<<8))

Definition at line 707 of file sqlite3.c.

#define SQLITE_CONSTRAINT_VTAB (SQLITE_CONSTRAINT | (9<<8))

Definition at line 708 of file sqlite3.c.

#define SQLITE_COPY 0 /* No longer used */

Definition at line 2875 of file sqlite3.c.

#define SQLITE_CORE 1

Definition at line 20 of file sqlite3.c.

#define SQLITE_CORRUPT 11 /* The database disk image is malformed */

Definition at line 623 of file sqlite3.c.

#define SQLITE_CORRUPT_BKPT sqlite3CorruptError(__LINE__)

Definition at line 12930 of file sqlite3.c.

#define SQLITE_CORRUPT_VTAB (SQLITE_CORRUPT | (1<<8))

Definition at line 694 of file sqlite3.c.

#define SQLITE_CountRows 0x00000080 /* Count rows changed by INSERT, */

Definition at line 11122 of file sqlite3.c.

#define SQLITE_CoverIdxScan 0x0040 /* Covering index scans */

Definition at line 11159 of file sqlite3.c.

#define SQLITE_CREATE_INDEX 1 /* Index Name Table Name */

Definition at line 2843 of file sqlite3.c.

#define SQLITE_CREATE_TABLE 2 /* Table Name NULL */

Definition at line 2844 of file sqlite3.c.

#define SQLITE_CREATE_TEMP_INDEX 3 /* Index Name Table Name */

Definition at line 2845 of file sqlite3.c.

#define SQLITE_CREATE_TEMP_TABLE 4 /* Table Name NULL */

Definition at line 2846 of file sqlite3.c.

#define SQLITE_CREATE_TEMP_TRIGGER 5 /* Trigger Name Table Name */

Definition at line 2847 of file sqlite3.c.

#define SQLITE_CREATE_TEMP_VIEW 6 /* View Name NULL */

Definition at line 2848 of file sqlite3.c.

#define SQLITE_CREATE_TRIGGER 7 /* Trigger Name Table Name */

Definition at line 2849 of file sqlite3.c.

#define SQLITE_CREATE_VIEW 8 /* View Name NULL */

Definition at line 2850 of file sqlite3.c.

#define SQLITE_CREATE_VTABLE 29 /* Table Name Module Name */

Definition at line 2871 of file sqlite3.c.

#define SQLITE_DBCONFIG_ENABLE_FKEY 1002 /* int int* */

Definition at line 2082 of file sqlite3.c.

#define SQLITE_DBCONFIG_ENABLE_TRIGGER 1003 /* int int* */

Definition at line 2083 of file sqlite3.c.

#define SQLITE_DBCONFIG_LOOKASIDE 1001 /* void* int int */

Definition at line 2081 of file sqlite3.c.

#define SQLITE_DBSTATUS_CACHE_HIT 7

Definition at line 6831 of file sqlite3.c.

#define SQLITE_DBSTATUS_CACHE_MISS 8

Definition at line 6832 of file sqlite3.c.

#define SQLITE_DBSTATUS_CACHE_USED 1

Definition at line 6825 of file sqlite3.c.

#define SQLITE_DBSTATUS_CACHE_WRITE 9

Definition at line 6833 of file sqlite3.c.

#define SQLITE_DBSTATUS_DEFERRED_FKS 10

Definition at line 6834 of file sqlite3.c.

#define SQLITE_DBSTATUS_LOOKASIDE_HIT 4

Definition at line 6828 of file sqlite3.c.

#define SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL 6

Definition at line 6830 of file sqlite3.c.

#define SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE 5

Definition at line 6829 of file sqlite3.c.

#define SQLITE_DBSTATUS_LOOKASIDE_USED 0

Definition at line 6824 of file sqlite3.c.

#define SQLITE_DBSTATUS_MAX 10 /* Largest defined DBSTATUS */

Definition at line 6835 of file sqlite3.c.

#define SQLITE_DBSTATUS_SCHEMA_USED 2

Definition at line 6826 of file sqlite3.c.

#define SQLITE_DBSTATUS_STMT_USED 3

Definition at line 6827 of file sqlite3.c.

#define SQLITE_DEFAULT_AUTOVACUUM 0

Definition at line 9345 of file sqlite3.c.

#define SQLITE_DEFAULT_CACHE_SIZE 2000

Definition at line 8162 of file sqlite3.c.

#define SQLITE_DEFAULT_FILE_FORMAT 4

Definition at line 8839 of file sqlite3.c.

#define SQLITE_DEFAULT_FILE_PERMISSIONS 0644

Definition at line 25396 of file sqlite3.c.

#define SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT -1

Definition at line 10114 of file sqlite3.c.

#define SQLITE_DEFAULT_MEMSTATUS 1

Definition at line 8361 of file sqlite3.c.

#define SQLITE_DEFAULT_MMAP_SIZE 0

Definition at line 9128 of file sqlite3.c.

#define SQLITE_DEFAULT_MMAP_SIZE_xc 1 /* Exclude from ctime.c */

Definition at line 9129 of file sqlite3.c.

#define SQLITE_DEFAULT_PAGE_SIZE 1024

Definition at line 8211 of file sqlite3.c.

#define SQLITE_DEFAULT_PROXYDIR_PERMISSIONS 0755

Definition at line 25403 of file sqlite3.c.

#define SQLITE_DEFAULT_RECURSIVE_TRIGGERS 0

Definition at line 8847 of file sqlite3.c.

#define SQLITE_DEFAULT_SECTOR_SIZE 4096

Definition at line 10580 of file sqlite3.c.

#define SQLITE_DEFAULT_WAL_AUTOCHECKPOINT 1000

Definition at line 8170 of file sqlite3.c.

#define SQLITE_DEFAULT_WORKER_THREADS 0

Definition at line 8872 of file sqlite3.c.

#define SQLITE_DeferFKs 0x01000000 /* Defer all FK constraints */

Definition at line 11142 of file sqlite3.c.

#define SQLITE_DELETE 9 /* Table Name NULL */

Definition at line 2851 of file sqlite3.c.

#define SQLITE_DENY 1 /* Abort the SQL statement with an error */

Definition at line 2820 of file sqlite3.c.

#define SQLITE_DEPRECATED

Definition at line 281 of file sqlite3.c.

#define SQLITE_DETACH 25 /* Database Name NULL */

Definition at line 2867 of file sqlite3.c.

#define SQLITE_DETERMINISTIC 0x800

Definition at line 4478 of file sqlite3.c.

#define SQLITE_DistinctOpt 0x0020 /* DISTINCT using indexes */

Definition at line 11158 of file sqlite3.c.

#define SQLITE_DONE 101 /* sqlite3_step() has finished executing */

Definition at line 642 of file sqlite3.c.

#define SQLITE_DROP_INDEX 10 /* Index Name Table Name */

Definition at line 2852 of file sqlite3.c.

#define SQLITE_DROP_TABLE 11 /* Table Name NULL */

Definition at line 2853 of file sqlite3.c.

#define SQLITE_DROP_TEMP_INDEX 12 /* Index Name Table Name */

Definition at line 2854 of file sqlite3.c.

#define SQLITE_DROP_TEMP_TABLE 13 /* Table Name NULL */

Definition at line 2855 of file sqlite3.c.

#define SQLITE_DROP_TEMP_TRIGGER 14 /* Trigger Name Table Name */

Definition at line 2856 of file sqlite3.c.

#define SQLITE_DROP_TEMP_VIEW 15 /* View Name NULL */

Definition at line 2857 of file sqlite3.c.

#define SQLITE_DROP_TRIGGER 16 /* Trigger Name Table Name */

Definition at line 2858 of file sqlite3.c.

#define SQLITE_DROP_VIEW 17 /* View Name NULL */

Definition at line 2859 of file sqlite3.c.

#define SQLITE_DROP_VTABLE 30 /* Table Name Module Name */

Definition at line 2872 of file sqlite3.c.

#define SQLITE_DYNAMIC ((sqlite3_destructor_type)sqlite3MallocSize)

Definition at line 9213 of file sqlite3.c.

#define SQLITE_ECEL_DUP 0x01 /* Deep, not shallow copies */

Definition at line 13236 of file sqlite3.c.

#define SQLITE_ECEL_FACTOR 0x02 /* Factor out constant terms */

Definition at line 13237 of file sqlite3.c.

#define SQLITE_EMPTY 16 /* Database is empty */

Definition at line 628 of file sqlite3.c.

#define SQLITE_ENABLE_LOCKING_STYLE 0

Definition at line 25329 of file sqlite3.c.

#define SQLITE_EnableTrigger 0x00800000 /* True to enable triggers */

Definition at line 11141 of file sqlite3.c.

#define SQLITE_ERROR 1 /* SQL error or missing database */

Definition at line 613 of file sqlite3.c.

#define SQLITE_EXPERIMENTAL

Definition at line 282 of file sqlite3.c.

#define SQLITE_EXTENSION_INIT1 /*no-op*/

Definition at line 102376 of file sqlite3.c.

#define SQLITE_EXTENSION_INIT2 ( v ) (void)v; /* unused parameter */

Definition at line 102377 of file sqlite3.c.

#define SQLITE_EXTENSION_INIT3 /*no-op*/

Definition at line 102378 of file sqlite3.c.

#define SQLITE_EXTERN extern

Definition at line 256 of file sqlite3.c.

#define SQLITE_FactorOutConst 0x0008 /* Constant factoring */

Definition at line 11156 of file sqlite3.c.

#define SQLITE_FAIL 3

Definition at line 7803 of file sqlite3.c.

#define SQLITE_FAULTINJECTOR_COUNT 1

Definition at line 13652 of file sqlite3.c.

#define SQLITE_FAULTINJECTOR_MALLOC 0

Definition at line 13651 of file sqlite3.c.

#define SQLITE_FCNTL_BUSYHANDLER 15

Definition at line 1189 of file sqlite3.c.

#define SQLITE_FCNTL_CHUNK_SIZE 6

Definition at line 1180 of file sqlite3.c.

#define SQLITE_FCNTL_COMMIT_PHASETWO 22

Definition at line 1195 of file sqlite3.c.

#define SQLITE_FCNTL_DB_UNCHANGED 0xca093fa0

Definition at line 10714 of file sqlite3.c.

#define SQLITE_FCNTL_FILE_POINTER 7

Definition at line 1181 of file sqlite3.c.

#define SQLITE_FCNTL_GET_LOCKPROXYFILE 2

Definition at line 1176 of file sqlite3.c.

#define SQLITE_FCNTL_HAS_MOVED 20

Definition at line 1193 of file sqlite3.c.

#define SQLITE_FCNTL_LAST_ERRNO 4

Definition at line 1178 of file sqlite3.c.

#define SQLITE_FCNTL_LOCKSTATE 1

Definition at line 1175 of file sqlite3.c.

#define SQLITE_FCNTL_MMAP_SIZE 18

Definition at line 1191 of file sqlite3.c.

#define SQLITE_FCNTL_OVERWRITE 11

Definition at line 1185 of file sqlite3.c.

#define SQLITE_FCNTL_PERSIST_WAL 10

Definition at line 1184 of file sqlite3.c.

#define SQLITE_FCNTL_POWERSAFE_OVERWRITE 13

Definition at line 1187 of file sqlite3.c.

#define SQLITE_FCNTL_PRAGMA 14

Definition at line 1188 of file sqlite3.c.

#define SQLITE_FCNTL_SET_LOCKPROXYFILE 3

Definition at line 1177 of file sqlite3.c.

#define SQLITE_FCNTL_SIZE_HINT 5

Definition at line 1179 of file sqlite3.c.

#define SQLITE_FCNTL_SYNC 21

Definition at line 1194 of file sqlite3.c.

#define SQLITE_FCNTL_SYNC_OMITTED 8

Definition at line 1182 of file sqlite3.c.

#define SQLITE_FCNTL_TEMPFILENAME 16

Definition at line 1190 of file sqlite3.c.

#define SQLITE_FCNTL_TRACE 19

Definition at line 1192 of file sqlite3.c.

#define SQLITE_FCNTL_VFSNAME 12

Definition at line 1186 of file sqlite3.c.

#define SQLITE_FCNTL_WAL_BLOCK 24

Definition at line 1197 of file sqlite3.c.

#define SQLITE_FCNTL_WIN32_AV_RETRY 9

Definition at line 1183 of file sqlite3.c.

#define SQLITE_FCNTL_WIN32_SET_HANDLE 23

Definition at line 1196 of file sqlite3.c.

#define SQLITE_FILE_HEADER "SQLite format 3"

Definition at line 52360 of file sqlite3.c.

#define SQLITE_FLOAT 2

Definition at line 4088 of file sqlite3.c.

#define SQLITE_ForeignKeys 0x00080000 /* Enforce foreign key constraints */

Definition at line 11137 of file sqlite3.c.

#define SQLITE_FORMAT 24 /* Auxiliary database format error */

Definition at line 636 of file sqlite3.c.

#define SQLITE_FREE ( x ) free(x)

Definition at line 17084 of file sqlite3.c.

#define SQLITE_FSFLAGS_IS_MSDOS 0x1

Definition at line 25381 of file sqlite3.c.

#define SQLITE_FULL 13 /* Insertion failed because database is full */

Definition at line 625 of file sqlite3.c.

#define SQLITE_FullColNames 0x00000020 /* Show full column names on SELECT */

Definition at line 11120 of file sqlite3.c.

#define SQLITE_FullFSync 0x00000004 /* Use full fsync on the backend */

Definition at line 11117 of file sqlite3.c.

#define SQLITE_FUNC_CASE 0x008 /* Case-sensitive LIKE-type function */

Definition at line 11242 of file sqlite3.c.

#define SQLITE_FUNC_COALESCE 0x200 /* Built-in coalesce() or ifnull() */

Definition at line 11248 of file sqlite3.c.

#define SQLITE_FUNC_CONSTANT 0x800 /* Constant inputs give a constant output */

Definition at line 11250 of file sqlite3.c.

#define SQLITE_FUNC_COUNT 0x100 /* Built-in count(*) aggregate */

Definition at line 11247 of file sqlite3.c.

#define SQLITE_FUNC_ENCMASK 0x003 /* SQLITE_UTF8, SQLITE_UTF16BE or UTF16LE */

Definition at line 11240 of file sqlite3.c.

#define SQLITE_FUNC_EPHEM 0x010 /* Ephemeral. Delete with VDBE */

Definition at line 11243 of file sqlite3.c.

#define SQLITE_FUNC_LENGTH 0x040 /* Built-in length() function */

Definition at line 11245 of file sqlite3.c.

#define SQLITE_FUNC_LIKE 0x004 /* Candidate for the LIKE optimization */

Definition at line 11241 of file sqlite3.c.

#define SQLITE_FUNC_MINMAX 0x1000 /* True for min() and max() aggregates */

Definition at line 11251 of file sqlite3.c.

#define SQLITE_FUNC_NEEDCOLL 0x020 /* sqlite3GetFuncCollSeq() might be called */

Definition at line 11244 of file sqlite3.c.

#define SQLITE_FUNC_TYPEOF 0x080 /* Built-in typeof() function */

Definition at line 11246 of file sqlite3.c.

#define SQLITE_FUNC_UNLIKELY 0x400 /* Built-in unlikely() function */

Definition at line 11249 of file sqlite3.c.

#define SQLITE_FUNCTION 31 /* NULL Function Name */

Definition at line 2873 of file sqlite3.c.

#define SQLITE_GET_LOCKPROXYFILE SQLITE_FCNTL_GET_LOCKPROXYFILE

Definition at line 1200 of file sqlite3.c.

#define SQLITE_GroupByOrder 0x0004 /* GROUPBY cover of ORDERBY */

Definition at line 11155 of file sqlite3.c.

#define SQLITE_IDXTYPE_APPDEF 0 /* Created using CREATE INDEX */

Definition at line 11766 of file sqlite3.c.

#define SQLITE_IDXTYPE_PRIMARYKEY 2 /* Is the PRIMARY KEY for the table */

Definition at line 11768 of file sqlite3.c.

#define SQLITE_IDXTYPE_UNIQUE 1 /* Implements a UNIQUE constraint */

Definition at line 11767 of file sqlite3.c.

#define SQLITE_IGNORE 2 /* Don't allow access, but don't generate an error */

Definition at line 2821 of file sqlite3.c.

#define SQLITE_IgnoreChecks 0x00002000 /* Do not enforce check constraints */

Definition at line 11131 of file sqlite3.c.

#define SQLITE_INDEX_CONSTRAINT_EQ 2

Definition at line 5829 of file sqlite3.c.

#define SQLITE_INDEX_CONSTRAINT_GE 32

Definition at line 5833 of file sqlite3.c.

#define SQLITE_INDEX_CONSTRAINT_GT 4

Definition at line 5830 of file sqlite3.c.

#define SQLITE_INDEX_CONSTRAINT_LE 8

Definition at line 5831 of file sqlite3.c.

#define SQLITE_INDEX_CONSTRAINT_LT 16

Definition at line 5832 of file sqlite3.c.

#define SQLITE_INDEX_CONSTRAINT_MATCH 64

Definition at line 5834 of file sqlite3.c.

#define SQLITE_INSERT 18 /* Table Name NULL */

Definition at line 2860 of file sqlite3.c.

#define SQLITE_INT_TO_PTR ( X ) ((void*)&((char*)0)[X])

Definition at line 8306 of file sqlite3.c.

#define SQLITE_INTEGER 1

Definition at line 4087 of file sqlite3.c.

#define SQLITE_INTEGRITY_CHECK_ERROR_MAX 100

#define SQLITE_INTERNAL 2 /* Internal logic error in SQLite */

Definition at line 614 of file sqlite3.c.

#define SQLITE_InternChanges 0x00000002 /* Uncommitted Hash table changes */

Definition at line 11116 of file sqlite3.c.

#define SQLITE_INTERRUPT 9 /* Operation terminated by sqlite3_interrupt()*/

Definition at line 621 of file sqlite3.c.

#define SQLITE_IOCAP_ATOMIC 0x00000001

Definition at line 773 of file sqlite3.c.

#define SQLITE_IOCAP_ATOMIC16K 0x00000040

Definition at line 779 of file sqlite3.c.

#define SQLITE_IOCAP_ATOMIC1K 0x00000004

Definition at line 775 of file sqlite3.c.

#define SQLITE_IOCAP_ATOMIC2K 0x00000008

Definition at line 776 of file sqlite3.c.

#define SQLITE_IOCAP_ATOMIC32K 0x00000080

Definition at line 780 of file sqlite3.c.

#define SQLITE_IOCAP_ATOMIC4K 0x00000010

Definition at line 777 of file sqlite3.c.

#define SQLITE_IOCAP_ATOMIC512 0x00000002

Definition at line 774 of file sqlite3.c.

#define SQLITE_IOCAP_ATOMIC64K 0x00000100

Definition at line 781 of file sqlite3.c.

#define SQLITE_IOCAP_ATOMIC8K 0x00000020

Definition at line 778 of file sqlite3.c.

#define SQLITE_IOCAP_IMMUTABLE 0x00002000

Definition at line 786 of file sqlite3.c.

#define SQLITE_IOCAP_POWERSAFE_OVERWRITE 0x00001000

Definition at line 785 of file sqlite3.c.

#define SQLITE_IOCAP_SAFE_APPEND 0x00000200

Definition at line 782 of file sqlite3.c.

#define SQLITE_IOCAP_SEQUENTIAL 0x00000400

Definition at line 783 of file sqlite3.c.

#define SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN 0x00000800

Definition at line 784 of file sqlite3.c.

#define SQLITE_IOERR 10 /* Some kind of disk I/O error occurred */

Definition at line 622 of file sqlite3.c.

#define SQLITE_IOERR_ACCESS (SQLITE_IOERR | (13<<8))

Definition at line 673 of file sqlite3.c.

#define SQLITE_IOERR_BLOCKED (SQLITE_IOERR | (11<<8))

Definition at line 671 of file sqlite3.c.

#define SQLITE_IOERR_CHECKRESERVEDLOCK (SQLITE_IOERR | (14<<8))

Definition at line 674 of file sqlite3.c.

#define SQLITE_IOERR_CLOSE (SQLITE_IOERR | (16<<8))

Definition at line 676 of file sqlite3.c.

#define SQLITE_IOERR_CONVPATH (SQLITE_IOERR | (26<<8))

Definition at line 686 of file sqlite3.c.

#define SQLITE_IOERR_DELETE (SQLITE_IOERR | (10<<8))

Definition at line 670 of file sqlite3.c.

#define SQLITE_IOERR_DELETE_NOENT (SQLITE_IOERR | (23<<8))

Definition at line 683 of file sqlite3.c.

#define SQLITE_IOERR_DIR_CLOSE (SQLITE_IOERR | (17<<8))

Definition at line 677 of file sqlite3.c.

#define SQLITE_IOERR_DIR_FSYNC (SQLITE_IOERR | (5<<8))

Definition at line 665 of file sqlite3.c.

#define SQLITE_IOERR_FSTAT (SQLITE_IOERR | (7<<8))

Definition at line 667 of file sqlite3.c.

#define SQLITE_IOERR_FSYNC (SQLITE_IOERR | (4<<8))

Definition at line 664 of file sqlite3.c.

#define SQLITE_IOERR_GETTEMPPATH (SQLITE_IOERR | (25<<8))

Definition at line 685 of file sqlite3.c.

#define SQLITE_IOERR_LOCK (SQLITE_IOERR | (15<<8))

Definition at line 675 of file sqlite3.c.

#define SQLITE_IOERR_MMAP (SQLITE_IOERR | (24<<8))

Definition at line 684 of file sqlite3.c.

#define SQLITE_IOERR_NOMEM (SQLITE_IOERR | (12<<8))

Definition at line 672 of file sqlite3.c.

#define SQLITE_IOERR_RDLOCK (SQLITE_IOERR | (9<<8))

Definition at line 669 of file sqlite3.c.

#define SQLITE_IOERR_READ (SQLITE_IOERR | (1<<8))

Definition at line 661 of file sqlite3.c.

#define SQLITE_IOERR_SEEK (SQLITE_IOERR | (22<<8))

Definition at line 682 of file sqlite3.c.

#define SQLITE_IOERR_SHMLOCK (SQLITE_IOERR | (20<<8))

Definition at line 680 of file sqlite3.c.

#define SQLITE_IOERR_SHMMAP (SQLITE_IOERR | (21<<8))

Definition at line 681 of file sqlite3.c.

#define SQLITE_IOERR_SHMOPEN (SQLITE_IOERR | (18<<8))

Definition at line 678 of file sqlite3.c.

#define SQLITE_IOERR_SHMSIZE (SQLITE_IOERR | (19<<8))

Definition at line 679 of file sqlite3.c.

#define SQLITE_IOERR_SHORT_READ (SQLITE_IOERR | (2<<8))

Definition at line 662 of file sqlite3.c.

#define SQLITE_IOERR_TRUNCATE (SQLITE_IOERR | (6<<8))

Definition at line 666 of file sqlite3.c.

#define SQLITE_IOERR_UNLOCK (SQLITE_IOERR | (8<<8))

Definition at line 668 of file sqlite3.c.

#define SQLITE_IOERR_WRITE (SQLITE_IOERR | (3<<8))

Definition at line 663 of file sqlite3.c.

#define SQLITE_JUMPIFNULL 0x10 /* jumps if either operand is NULL */

Definition at line 11418 of file sqlite3.c.

#define SQLITE_LAST_ERRNO SQLITE_FCNTL_LAST_ERRNO

Definition at line 1202 of file sqlite3.c.

#define SQLITE_LegacyFileFmt 0x00008000 /* Create new databases in format 1 */

Definition at line 11133 of file sqlite3.c.

#define SQLITE_LIMIT_ATTACHED 7

Definition at line 3409 of file sqlite3.c.

#define SQLITE_LIMIT_COLUMN 2

Definition at line 3404 of file sqlite3.c.

#define SQLITE_LIMIT_COMPOUND_SELECT 4

Definition at line 3406 of file sqlite3.c.

#define SQLITE_LIMIT_EXPR_DEPTH 3

Definition at line 3405 of file sqlite3.c.

#define SQLITE_LIMIT_FUNCTION_ARG 6

Definition at line 3408 of file sqlite3.c.

#define SQLITE_LIMIT_LENGTH 0

Definition at line 3402 of file sqlite3.c.

#define SQLITE_LIMIT_LIKE_PATTERN_LENGTH 8

Definition at line 3410 of file sqlite3.c.

#define SQLITE_LIMIT_SQL_LENGTH 1

Definition at line 3403 of file sqlite3.c.

#define SQLITE_LIMIT_TRIGGER_DEPTH 10

Definition at line 3412 of file sqlite3.c.

#define SQLITE_LIMIT_VARIABLE_NUMBER 9

Definition at line 3411 of file sqlite3.c.

#define SQLITE_LIMIT_VDBE_OP 5

Definition at line 3407 of file sqlite3.c.

#define SQLITE_LIMIT_WORKER_THREADS 11

Definition at line 3413 of file sqlite3.c.

#define SQLITE_LITTLEENDIAN (*(char *)(&sqlite3one)==1)

Definition at line 9054 of file sqlite3.c.

#define SQLITE_LoadExtension 0x00400000 /* Enable load_extension */

Definition at line 11140 of file sqlite3.c.

#define SQLITE_LOCK_EXCLUSIVE 4

Definition at line 799 of file sqlite3.c.

#define SQLITE_LOCK_NONE 0

Definition at line 795 of file sqlite3.c.

#define SQLITE_LOCK_PENDING 3

Definition at line 798 of file sqlite3.c.

#define SQLITE_LOCK_RESERVED 2

Definition at line 797 of file sqlite3.c.

#define SQLITE_LOCK_SHARED 1

Definition at line 796 of file sqlite3.c.

#define SQLITE_LOCKED 6 /* A table in the database is locked */

Definition at line 618 of file sqlite3.c.

#define SQLITE_LOCKED_SHAREDCACHE (SQLITE_LOCKED | (1<<8))

Definition at line 687 of file sqlite3.c.

#define SQLITE_MAGIC_BUSY 0xf03b7906 /* Database currently in use */

Definition at line 11192 of file sqlite3.c.

#define SQLITE_MAGIC_CLOSED 0x9f3c2d33 /* Database is closed */

Definition at line 11190 of file sqlite3.c.

#define SQLITE_MAGIC_ERROR 0xb5357930 /* An SQLITE_MISUSE error occurred */

Definition at line 11193 of file sqlite3.c.

#define SQLITE_MAGIC_OPEN 0xa029a697 /* Database is open */

Definition at line 11189 of file sqlite3.c.

#define SQLITE_MAGIC_SICK 0x4b771290 /* Error and awaiting close */

Definition at line 11191 of file sqlite3.c.

#define SQLITE_MAGIC_ZOMBIE 0x64cffc7f /* Close with last statement close */

Definition at line 11194 of file sqlite3.c.

#define SQLITE_MALLOC ( x ) malloc(x)

Definition at line 17083 of file sqlite3.c.

#define SQLITE_MALLOC_SOFT_LIMIT 1024

Definition at line 8402 of file sqlite3.c.

#define SQLITE_MAX_ATTACHED 10

Definition at line 8179 of file sqlite3.c.

#define SQLITE_MAX_COLUMN 2000

Definition at line 8097 of file sqlite3.c.

#define SQLITE_MAX_COMPOUND_SELECT 500

Definition at line 8134 of file sqlite3.c.

#define SQLITE_MAX_DEFAULT_PAGE_SIZE 8192

Definition at line 8226 of file sqlite3.c.

#define SQLITE_MAX_EXPR_DEPTH 1000

Definition at line 8122 of file sqlite3.c.

#define SQLITE_MAX_FILE_FORMAT 4

Definition at line 8837 of file sqlite3.c.

#define SQLITE_MAX_FUNCTION_ARG 127

Definition at line 8149 of file sqlite3.c.

#define SQLITE_MAX_LENGTH 1000000000

Definition at line 8076 of file sqlite3.c.

#define SQLITE_MAX_LIKE_PATTERN_LENGTH 50000

Definition at line 8250 of file sqlite3.c.

#define SQLITE_MAX_MMAP_SIZE 0

Definition at line 9117 of file sqlite3.c.

#define SQLITE_MAX_MMAP_SIZE_xc 1 /* exclude from ctime.c */

Definition at line 9119 of file sqlite3.c.

#define SQLITE_MAX_PAGE_COUNT 1073741823

Definition at line 8242 of file sqlite3.c.

#define SQLITE_MAX_PAGE_SIZE 65536

Definition at line 8204 of file sqlite3.c.

#define SQLITE_MAX_PMASZ (1<<29)

Definition at line 78084 of file sqlite3.c.

#define SQLITE_MAX_SCHEMA_RETRY 50

Definition at line 14525 of file sqlite3.c.

#define SQLITE_MAX_SQL_LENGTH 1000000000

Definition at line 8108 of file sqlite3.c.

#define SQLITE_MAX_TRIGGER_DEPTH 1000

Definition at line 8261 of file sqlite3.c.

#define SQLITE_MAX_U32 ((((u64)1)<<32)-1)

Definition at line 8968 of file sqlite3.c.

#define SQLITE_MAX_VARIABLE_NUMBER 999

Definition at line 8187 of file sqlite3.c.

#define SQLITE_MAX_VDBE_OP 25000

Definition at line 8142 of file sqlite3.c.

#define SQLITE_MAX_WORKER_THREADS 8

Definition at line 8869 of file sqlite3.c.

#define SQLITE_MINIMUM_FILE_DESCRIPTOR 3

Definition at line 26027 of file sqlite3.c.

#define SQLITE_MISMATCH 20 /* Data type mismatch */

Definition at line 632 of file sqlite3.c.

#define SQLITE_MISUSE 21 /* Library used incorrectly */

Definition at line 633 of file sqlite3.c.

#define SQLITE_MISUSE_BKPT sqlite3MisuseError(__LINE__)

Definition at line 12931 of file sqlite3.c.

#define SQLITE_MUTEX_FAST 0

Definition at line 6466 of file sqlite3.c.

#define SQLITE_MUTEX_NREF 0

Definition at line 19511 of file sqlite3.c.

#define SQLITE_MUTEX_PTHREADS

Definition at line 10799 of file sqlite3.c.

#define SQLITE_MUTEX_RECURSIVE 1

Definition at line 6467 of file sqlite3.c.

#define SQLITE_MUTEX_STATIC_APP1 8 /* For use by application */

Definition at line 6476 of file sqlite3.c.

#define SQLITE_MUTEX_STATIC_APP2 9 /* For use by application */

Definition at line 6477 of file sqlite3.c.

#define SQLITE_MUTEX_STATIC_APP3 10 /* For use by application */

Definition at line 6478 of file sqlite3.c.

#define SQLITE_MUTEX_STATIC_LRU 6 /* lru page list */

Definition at line 6473 of file sqlite3.c.

#define SQLITE_MUTEX_STATIC_LRU2 7 /* NOT USED */

Definition at line 6474 of file sqlite3.c.

#define SQLITE_MUTEX_STATIC_MASTER 2

Definition at line 6468 of file sqlite3.c.

#define SQLITE_MUTEX_STATIC_MEM 3 /* sqlite3_malloc() */

Definition at line 6469 of file sqlite3.c.

#define SQLITE_MUTEX_STATIC_MEM2 4 /* NOT USED */

Definition at line 6470 of file sqlite3.c.

#define SQLITE_MUTEX_STATIC_OPEN 4 /* sqlite3BtreeOpen() */

Definition at line 6471 of file sqlite3.c.

#define SQLITE_MUTEX_STATIC_PMEM 7 /* sqlite3PageMalloc() */

Definition at line 6475 of file sqlite3.c.

#define SQLITE_MUTEX_STATIC_PRNG 5 /* sqlite3_random() */

Definition at line 6472 of file sqlite3.c.

#define SQLITE_N_BTREE_META 16

Definition at line 9338 of file sqlite3.c.

#define SQLITE_N_COLCACHE 10

Definition at line 12435 of file sqlite3.c.

#define SQLITE_N_KEYWORD 124

Definition at line 127153 of file sqlite3.c.

#define SQLITE_N_LIMIT (SQLITE_LIMIT_WORKER_THREADS+1)

Definition at line 10902 of file sqlite3.c.

#define SQLITE_NOINLINE

Definition at line 8325 of file sqlite3.c.

#define SQLITE_NOLFS 22 /* Uses OS features not supported on host */

Definition at line 634 of file sqlite3.c.

#define SQLITE_NOMEM 7 /* A malloc() failed */

Definition at line 619 of file sqlite3.c.

#define SQLITE_NOTADB 26 /* File opened that is not a database file */

Definition at line 638 of file sqlite3.c.

#define SQLITE_NOTFOUND 12 /* Unknown opcode in sqlite3_file_control() */

Definition at line 624 of file sqlite3.c.

#define SQLITE_NOTICE 27 /* Notifications from sqlite3_log() */

Definition at line 639 of file sqlite3.c.

#define SQLITE_NOTICE_RECOVER_ROLLBACK (SQLITE_NOTICE | (2<<8))

Definition at line 711 of file sqlite3.c.

#define SQLITE_NOTICE_RECOVER_WAL (SQLITE_NOTICE | (1<<8))

Definition at line 710 of file sqlite3.c.

#define SQLITE_NOTNULL 0x90 /* Assert that operands are never NULL */

Definition at line 11421 of file sqlite3.c.

#define SQLITE_NULL 5

Definition at line 4090 of file sqlite3.c.

#define SQLITE_NullCallback 0x00000100 /* Invoke the callback once if the */

Definition at line 11125 of file sqlite3.c.

#define SQLITE_NULLEQ 0x80 /* NULL=NULL */

Definition at line 11420 of file sqlite3.c.

#define SQLITE_OK 0 /* Successful result */

Definition at line 611 of file sqlite3.c.

#define SQLITE_OmitNoopJoin 0x0400 /* Omit unused tables in joins */

Definition at line 11163 of file sqlite3.c.

#define SQLITE_OPEN_AUTOPROXY 0x00000020 /* VFS only */

Definition at line 727 of file sqlite3.c.

#define SQLITE_OPEN_CREATE 0x00000004 /* Ok for sqlite3_open_v2() */

Definition at line 724 of file sqlite3.c.

#define SQLITE_OPEN_DELETEONCLOSE 0x00000008 /* VFS only */

Definition at line 725 of file sqlite3.c.

#define SQLITE_OPEN_EXCLUSIVE 0x00000010 /* VFS only */

Definition at line 726 of file sqlite3.c.

#define SQLITE_OPEN_FULLMUTEX 0x00010000 /* Ok for sqlite3_open_v2() */

Definition at line 738 of file sqlite3.c.

#define SQLITE_OPEN_MAIN_DB 0x00000100 /* VFS only */

Definition at line 730 of file sqlite3.c.

#define SQLITE_OPEN_MAIN_JOURNAL 0x00000800 /* VFS only */

Definition at line 733 of file sqlite3.c.

#define SQLITE_OPEN_MASTER_JOURNAL 0x00004000 /* VFS only */

Definition at line 736 of file sqlite3.c.

#define SQLITE_OPEN_MEMORY 0x00000080 /* Ok for sqlite3_open_v2() */

Definition at line 729 of file sqlite3.c.

#define SQLITE_OPEN_NOMUTEX 0x00008000 /* Ok for sqlite3_open_v2() */

Definition at line 737 of file sqlite3.c.

#define SQLITE_OPEN_PRIVATECACHE 0x00040000 /* Ok for sqlite3_open_v2() */

Definition at line 740 of file sqlite3.c.

#define SQLITE_OPEN_READONLY 0x00000001 /* Ok for sqlite3_open_v2() */

Definition at line 722 of file sqlite3.c.

#define SQLITE_OPEN_READWRITE 0x00000002 /* Ok for sqlite3_open_v2() */

Definition at line 723 of file sqlite3.c.

#define SQLITE_OPEN_SHAREDCACHE 0x00020000 /* Ok for sqlite3_open_v2() */

Definition at line 739 of file sqlite3.c.

#define SQLITE_OPEN_SUBJOURNAL 0x00002000 /* VFS only */

Definition at line 735 of file sqlite3.c.

#define SQLITE_OPEN_TEMP_DB 0x00000200 /* VFS only */

Definition at line 731 of file sqlite3.c.

#define SQLITE_OPEN_TEMP_JOURNAL 0x00001000 /* VFS only */

Definition at line 734 of file sqlite3.c.

#define SQLITE_OPEN_TRANSIENT_DB 0x00000400 /* VFS only */

Definition at line 732 of file sqlite3.c.

#define SQLITE_OPEN_URI 0x00000040 /* Ok for sqlite3_open_v2() */

Definition at line 728 of file sqlite3.c.

#define SQLITE_OPEN_WAL 0x00080000 /* VFS only */

Definition at line 741 of file sqlite3.c.

#define SQLITE_OrderByIdxJoin 0x0080 /* ORDER BY of joins via index */

Definition at line 11160 of file sqlite3.c.

#define SQLITE_OS_OTHER 0

Definition at line 10545 of file sqlite3.c.

#define SQLITE_OS_UNIX 1

Definition at line 10553 of file sqlite3.c.

#define SQLITE_OS_WIN 0

Definition at line 10552 of file sqlite3.c.

#define SQLITE_PERM 3 /* Access permission denied */

Definition at line 615 of file sqlite3.c.

#define SQLITE_POWERSAFE_OVERWRITE 1

Definition at line 8352 of file sqlite3.c.

#define SQLITE_PRAGMA 19 /* Pragma Name 1st arg or NULL */

Definition at line 2861 of file sqlite3.c.

#define SQLITE_PreferBuiltin 0x00200000 /* Preference to built-in funcs */

Definition at line 11139 of file sqlite3.c.

#define SQLITE_PRINT_BUF_SIZE 70

Definition at line 21517 of file sqlite3.c.

#define SQLITE_PRINTF_INTERNAL 0x01

Definition at line 13065 of file sqlite3.c.

#define SQLITE_PRINTF_SQLFUNC 0x02

Definition at line 13066 of file sqlite3.c.

#define SQLITE_PRIVATE static

Definition at line 23 of file sqlite3.c.

#define SQLITE_PROTOCOL 15 /* Database lock protocol error */

Definition at line 627 of file sqlite3.c.

#define SQLITE_PTR_TO_INT ( X ) ((int)(((char*)X)-(char*)0))

Definition at line 8307 of file sqlite3.c.

#define SQLITE_PTRSIZE 8

Definition at line 9017 of file sqlite3.c.

#define SQLITE_QueryFlattener 0x0001 /* Query flattening */

Definition at line 11153 of file sqlite3.c.

#define SQLITE_QueryOnly 0x02000000 /* Disable database changes */

Definition at line 11143 of file sqlite3.c.

#define SQLITE_RANGE 25 /* 2nd parameter to sqlite3_bind out of range */

Definition at line 637 of file sqlite3.c.

#define SQLITE_READ 20 /* Table Name Column Name */

Definition at line 2862 of file sqlite3.c.

#define SQLITE_READONLY 8 /* Attempt to write a readonly database */

Definition at line 620 of file sqlite3.c.

#define SQLITE_READONLY_CANTLOCK (SQLITE_READONLY | (2<<8))

Definition at line 696 of file sqlite3.c.

#define SQLITE_READONLY_DBMOVED (SQLITE_READONLY | (4<<8))

Definition at line 698 of file sqlite3.c.

#define SQLITE_READONLY_RECOVERY (SQLITE_READONLY | (1<<8))

Definition at line 695 of file sqlite3.c.

#define SQLITE_READONLY_ROLLBACK (SQLITE_READONLY | (3<<8))

Definition at line 697 of file sqlite3.c.

#define SQLITE_ReadUncommitted 0x0004000 /* For shared-cache mode */

Definition at line 11132 of file sqlite3.c.

#define SQLITE_REALLOC	(	x,
		y
	)	realloc((x),(y))

Definition at line 17085 of file sqlite3.c.

#define SQLITE_RecoveryMode 0x00010000 /* Ignore schema errors */

Definition at line 11134 of file sqlite3.c.

#define SQLITE_RecTriggers 0x00040000 /* Enable recursive triggers */

Definition at line 11136 of file sqlite3.c.

#define SQLITE_RECURSIVE 33 /* NULL NULL */

Definition at line 2876 of file sqlite3.c.

#define SQLITE_REINDEX 27 /* Index Name NULL */

Definition at line 2869 of file sqlite3.c.

#define SQLITE_REPLACE 5

Definition at line 7805 of file sqlite3.c.

#define SQLITE_ReverseOrder 0x00020000 /* Reverse unordered SELECTs */

Definition at line 11135 of file sqlite3.c.

#define SQLITE_ROLLBACK 1

Definition at line 7801 of file sqlite3.c.

#define SQLITE_ROW 100 /* sqlite3_step() has another row ready */

Definition at line 641 of file sqlite3.c.

#define SQLITE_SAVEPOINT 32 /* Operation Savepoint Name */

Definition at line 2874 of file sqlite3.c.

#define SQLITE_SCANSTAT_EST 2

Definition at line 7856 of file sqlite3.c.

#define SQLITE_SCANSTAT_EXPLAIN 4

Definition at line 7858 of file sqlite3.c.

#define SQLITE_SCANSTAT_NAME 3

Definition at line 7857 of file sqlite3.c.

#define SQLITE_SCANSTAT_NLOOP 0

Definition at line 7854 of file sqlite3.c.

#define SQLITE_SCANSTAT_NVISIT 1

Definition at line 7855 of file sqlite3.c.

#define SQLITE_SCANSTAT_SELECTID 5

Definition at line 7859 of file sqlite3.c.

#define SQLITE_SCHEMA 17 /* The database schema changed */

Definition at line 629 of file sqlite3.c.

#define SQLITE_SELECT 21 /* NULL NULL */

Definition at line 2863 of file sqlite3.c.

#define SQLITE_SET_LOCKPROXYFILE SQLITE_FCNTL_SET_LOCKPROXYFILE

Definition at line 1201 of file sqlite3.c.

#define SQLITE_SHM_EXCLUSIVE 8

Definition at line 1464 of file sqlite3.c.

#define SQLITE_SHM_LOCK 2

Definition at line 1462 of file sqlite3.c.

#define SQLITE_SHM_NLOCK 8

Definition at line 1474 of file sqlite3.c.

#define SQLITE_SHM_SHARED 4

Definition at line 1463 of file sqlite3.c.

#define SQLITE_SHM_UNLOCK 1

Definition at line 1461 of file sqlite3.c.

#define SQLITE_ShortColNames 0x00000040 /* Show short columns names */

Definition at line 11121 of file sqlite3.c.

#define SQLITE_SKIP_UTF8 ( zIn )

Value:

{                        \
  if( (*(zIn++))>=0xc0 ){                              \
    while( (*zIn & 0xc0)==0x80 ){ zIn++; }             \
  }                                                    \
}

Definition at line 12914 of file sqlite3.c.

#define SQLITE_SO_ASC 0 /* Sort in ascending order */

Definition at line 11378 of file sqlite3.c.

#define SQLITE_SO_DESC 1 /* Sort in ascending order */

Definition at line 11379 of file sqlite3.c.

#define SQLITE_SORTER_PMASZ 250

Definition at line 13948 of file sqlite3.c.

#define SQLITE_SOURCE_ID "2015-04-23 13:37:05 b5e43602833249aa4b73337bf85b7f308450dab6"

Definition at line 323 of file sqlite3.c.

#define SQLITE_SqlTrace 0x00000200 /* Debug print SQL as it executes */

Definition at line 11127 of file sqlite3.c.

#define SQLITE_Stat34 0x0800 /* Use STAT3 or STAT4 data */

Definition at line 11164 of file sqlite3.c.

#define SQLITE_STAT4_SAMPLES 1

Definition at line 88223 of file sqlite3.c.

#define SQLITE_STATIC ((sqlite3_destructor_type)0)

Definition at line 4701 of file sqlite3.c.

#define SQLITE_STATUS_MALLOC_COUNT 9

Definition at line 6707 of file sqlite3.c.

#define SQLITE_STATUS_MALLOC_SIZE 5

Definition at line 6703 of file sqlite3.c.

#define SQLITE_STATUS_MEMORY_USED 0

Definition at line 6698 of file sqlite3.c.

#define SQLITE_STATUS_PAGECACHE_OVERFLOW 2

Definition at line 6700 of file sqlite3.c.

#define SQLITE_STATUS_PAGECACHE_SIZE 7

Definition at line 6705 of file sqlite3.c.

#define SQLITE_STATUS_PAGECACHE_USED 1

Definition at line 6699 of file sqlite3.c.

#define SQLITE_STATUS_PARSER_STACK 6

Definition at line 6704 of file sqlite3.c.

#define SQLITE_STATUS_SCRATCH_OVERFLOW 4

Definition at line 6702 of file sqlite3.c.

#define SQLITE_STATUS_SCRATCH_SIZE 8

Definition at line 6706 of file sqlite3.c.

#define SQLITE_STATUS_SCRATCH_USED 3

Definition at line 6701 of file sqlite3.c.

#define SQLITE_STDCALL

Definition at line 265 of file sqlite3.c.

#define SQLITE_STMTSTATUS_AUTOINDEX 3

Definition at line 6903 of file sqlite3.c.

#define SQLITE_STMTSTATUS_FULLSCAN_STEP 1

Definition at line 6901 of file sqlite3.c.

#define SQLITE_STMTSTATUS_SORT 2

Definition at line 6902 of file sqlite3.c.

#define SQLITE_STMTSTATUS_VM_STEP 4

Definition at line 6904 of file sqlite3.c.

#define SQLITE_STOREP2 0x20 /* Store result in reg[P2] rather than jump */

Definition at line 11419 of file sqlite3.c.

#define SQLITE_SubqCoroutine 0x0100 /* Evaluate subqueries as coroutines */

Definition at line 11161 of file sqlite3.c.

#define SQLITE_SYNC_DATAONLY 0x00010

Definition at line 829 of file sqlite3.c.

#define SQLITE_SYNC_FULL 0x00003

Definition at line 828 of file sqlite3.c.

#define SQLITE_SYNC_MASK 0x13 /* Mask off the SQLITE_SYNC_* values */

Definition at line 41572 of file sqlite3.c.

#define SQLITE_SYNC_NORMAL 0x00002

Definition at line 827 of file sqlite3.c.

#define SQLITE_SYSTEM_MALLOC 1

Definition at line 8394 of file sqlite3.c.

#define SQLITE_TEMP_FILE_PREFIX "etilqs_"

Definition at line 10605 of file sqlite3.c.

#define SQLITE_TEMP_STORE 1

Definition at line 8855 of file sqlite3.c.

#define SQLITE_TEMP_STORE_xc 1 /* Exclude from ctime.c */

Definition at line 8856 of file sqlite3.c.

#define SQLITE_TESTCTRL_ALWAYS 13

Definition at line 6566 of file sqlite3.c.

#define SQLITE_TESTCTRL_ASSERT 12

Definition at line 6565 of file sqlite3.c.

#define SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS 10

Definition at line 6563 of file sqlite3.c.

#define SQLITE_TESTCTRL_BITVEC_TEST 8

Definition at line 6561 of file sqlite3.c.

#define SQLITE_TESTCTRL_BYTEORDER 22

Definition at line 6575 of file sqlite3.c.

#define SQLITE_TESTCTRL_EXPLAIN_STMT 19 /* NOT USED */

Definition at line 6572 of file sqlite3.c.

#define SQLITE_TESTCTRL_FAULT_INSTALL 9

Definition at line 6562 of file sqlite3.c.

#define SQLITE_TESTCTRL_FIRST 5

Definition at line 6557 of file sqlite3.c.

#define SQLITE_TESTCTRL_IMPOSTER 25

Definition at line 6578 of file sqlite3.c.

#define SQLITE_TESTCTRL_ISINIT 23

Definition at line 6576 of file sqlite3.c.

#define SQLITE_TESTCTRL_ISKEYWORD 16

Definition at line 6569 of file sqlite3.c.

#define SQLITE_TESTCTRL_LAST 25

Definition at line 6579 of file sqlite3.c.

#define SQLITE_TESTCTRL_LOCALTIME_FAULT 18

Definition at line 6571 of file sqlite3.c.

#define SQLITE_TESTCTRL_NEVER_CORRUPT 20

Definition at line 6573 of file sqlite3.c.

#define SQLITE_TESTCTRL_OPTIMIZATIONS 15

Definition at line 6568 of file sqlite3.c.

#define SQLITE_TESTCTRL_PENDING_BYTE 11

Definition at line 6564 of file sqlite3.c.

#define SQLITE_TESTCTRL_PRNG_RESET 7

Definition at line 6560 of file sqlite3.c.

#define SQLITE_TESTCTRL_PRNG_RESTORE 6

Definition at line 6559 of file sqlite3.c.

#define SQLITE_TESTCTRL_PRNG_SAVE 5

Definition at line 6558 of file sqlite3.c.

#define SQLITE_TESTCTRL_RESERVE 14

Definition at line 6567 of file sqlite3.c.

#define SQLITE_TESTCTRL_SCRATCHMALLOC 17

Definition at line 6570 of file sqlite3.c.

#define SQLITE_TESTCTRL_SORTER_MMAP 24

Definition at line 6577 of file sqlite3.c.

#define SQLITE_TESTCTRL_VDBE_COVERAGE 21

Definition at line 6574 of file sqlite3.c.

#define SQLITE_TEXT 3

Definition at line 4094 of file sqlite3.c.

#define SQLITE_THREADS_IMPLEMENTED 1 /* Prevent the single-thread code below */

Definition at line 22679 of file sqlite3.c.

#define SQLITE_THREADSAFE 1 /* IMP: R-07272-22309 */

Definition at line 8343 of file sqlite3.c.

#define SQLITE_TOOBIG 18 /* String or BLOB exceeds size limit */

Definition at line 630 of file sqlite3.c.

#define SQLITE_TRANSACTION 22 /* Operation NULL */

Definition at line 2864 of file sqlite3.c.

#define SQLITE_TRANSIENT ((sqlite3_destructor_type)-1)

Definition at line 4702 of file sqlite3.c.

#define SQLITE_Transitive 0x0200 /* Transitive constraints */

Definition at line 11162 of file sqlite3.c.

#define SQLITE_UNIX_THREADS 1

Definition at line 25389 of file sqlite3.c.

#define SQLITE_UPDATE 23 /* Table Name Column Name */

Definition at line 2865 of file sqlite3.c.

#define SQLITE_USE_URI 0

Definition at line 13933 of file sqlite3.c.

#define SQLITE_UTF16 4 /* Use native byte order */

Definition at line 4466 of file sqlite3.c.

#define SQLITE_UTF16_ALIGNED 8 /* sqlite3_create_collation only */

Definition at line 4468 of file sqlite3.c.

#define SQLITE_UTF16BE 3 /* IMP: R-51971-34154 */

Definition at line 4465 of file sqlite3.c.

#define SQLITE_UTF16LE 2 /* IMP: R-03371-37637 */

Definition at line 4464 of file sqlite3.c.

#define SQLITE_UTF16NATIVE (SQLITE_BIGENDIAN?SQLITE_UTF16BE:SQLITE_UTF16LE)

Definition at line 9055 of file sqlite3.c.

#define SQLITE_UTF8 1 /* IMP: R-37514-35566 */

Definition at line 4463 of file sqlite3.c.

#define SQLITE_Vacuum 0x08000000 /* Currently in a VACUUM */

Definition at line 11145 of file sqlite3.c.

#define SQLITE_VdbeAddopTrace 0x00001000 /* Trace sqlite3VdbeAddOp() calls */

Definition at line 11130 of file sqlite3.c.

#define SQLITE_VdbeEQP 0x04000000 /* Debug EXPLAIN QUERY PLAN */

Definition at line 11144 of file sqlite3.c.

#define SQLITE_VdbeListing 0x00000400 /* Debug listings of VDBE programs */

Definition at line 11128 of file sqlite3.c.

#define SQLITE_VdbeTrace 0x00000001 /* True to trace VDBE execution */

Definition at line 11115 of file sqlite3.c.

#define SQLITE_VERSION "3.8.10"

Definition at line 321 of file sqlite3.c.

#define SQLITE_VERSION_NUMBER 3008010

Definition at line 322 of file sqlite3.c.

#define SQLITE_VTAB_CONSTRAINT_SUPPORT 1

Definition at line 7775 of file sqlite3.c.

#define SQLITE_WARNING 28 /* Warnings from sqlite3_log() */

Definition at line 640 of file sqlite3.c.

#define SQLITE_WARNING_AUTOINDEX (SQLITE_WARNING | (1<<8))

Definition at line 712 of file sqlite3.c.

#define SQLITE_WriteSchema 0x00000800 /* OK to update SQLITE_MASTER */

Definition at line 11129 of file sqlite3.c.

#define SQLITE_WSD

Definition at line 9236 of file sqlite3.c.

#define sqliteHashData ( E ) ((E)->data)

Definition at line 8617 of file sqlite3.c.

#define sqliteHashFirst ( H ) ((H)->first)

Definition at line 8615 of file sqlite3.c.

#define sqliteHashNext ( E ) ((E)->next)

Definition at line 8616 of file sqlite3.c.

#define SRT_Coroutine 13 /* Generate a single row of result */

Definition at line 12399 of file sqlite3.c.

#define SRT_Discard 4 /* Do not save the results anywhere */

Definition at line 12386 of file sqlite3.c.

#define SRT_DistFifo 6 /* Like SRT_Fifo, but unique results only */

Definition at line 12388 of file sqlite3.c.

#define SRT_DistQueue 8 /* Like SRT_Queue, but unique results only */

Definition at line 12390 of file sqlite3.c.

#define SRT_EphemTab 12 /* Create transient tab and store like SRT_Table */

Definition at line 12398 of file sqlite3.c.

#define SRT_Except 2 /* Remove result from a UNION index */

Definition at line 12384 of file sqlite3.c.

#define SRT_Exists 3 /* Store 1 if the result is not empty */

Definition at line 12385 of file sqlite3.c.

#define SRT_Fifo 5 /* Store result as data with an automatic rowid */

Definition at line 12387 of file sqlite3.c.

#define SRT_Mem 10 /* Store result in a memory cell */

Definition at line 12396 of file sqlite3.c.

#define SRT_Output 9 /* Output each row of result */

Definition at line 12395 of file sqlite3.c.

#define SRT_Queue 7 /* Store result in an queue */

Definition at line 12389 of file sqlite3.c.

#define SRT_Set 11 /* Store results as keys in an index */

Definition at line 12397 of file sqlite3.c.

#define SRT_Table 14 /* Store result as data with an automatic rowid */

Definition at line 12400 of file sqlite3.c.

#define SRT_Union 1 /* Store result as keys in an index */

Definition at line 12383 of file sqlite3.c.

#define SRVAL ( p ) ((void*)((SorterRecord*)(p) + 1))

Definition at line 78385 of file sqlite3.c.

#define STAT_GET_NDLT 4 /* "ndlt" column of stat[34] entry */

Definition at line 88862 of file sqlite3.c.

#define STAT_GET_NEQ 2 /* "neq" column of stat[34] entry */

Definition at line 88860 of file sqlite3.c.

#define STAT_GET_NLT 3 /* "nlt" column of stat[34] entry */

Definition at line 88861 of file sqlite3.c.

#define STAT_GET_ROWID 1 /* "rowid" column of stat[34] entry */

Definition at line 88859 of file sqlite3.c.

#define STAT_GET_STAT1 0 /* "stat" column of stat1 table */

Definition at line 88858 of file sqlite3.c.

#define STR_FUNCTION	(	zName,
		nArg,
		pArg,
		bNC,
		xFunc
	)

Value:

{nArg, SQLITE_FUNC_CONSTANT|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \

pArg, 0, xFunc, 0, 0, #zName, 0, 0}

SQLITE_UTF8

#define SQLITE_UTF8

Definition: sqlite3.c:4463

SQLITE_FUNC_CONSTANT

#define SQLITE_FUNC_CONSTANT

Definition: sqlite3.c:11250

SQLITE_FUNC_NEEDCOLL

#define SQLITE_FUNC_NEEDCOLL

Definition: sqlite3.c:11244

Definition at line 11290 of file sqlite3.c.

#define STRACCUM_NOMEM 1

Definition at line 12758 of file sqlite3.c.

#define STRACCUM_TOOBIG 2

Definition at line 12759 of file sqlite3.c.

#define STRICMP	(	x,
		y
	)

Value:

(\
sqlite3UpperToLower[*(unsigned char *)(x)]==   \
sqlite3UpperToLower[*(unsigned char *)(y)]     \
&& sqlite3StrICmp((x)+1,(y)+1)==0 )

Definition at line 91856 of file sqlite3.c.

#define Stringify	(	P,
		enc
	)

Value:

if(((P)->flags&(MEM_Str|MEM_Blob))==0 && sqlite3VdbeMemStringify(P,enc,0)) \

{ goto no_mem; }

MEM_Str

#define MEM_Str

Definition: sqlite3.c:14701

sqlite3VdbeMemStringify

SQLITE_PRIVATE int sqlite3VdbeMemStringify(Mem *, u8, u8)

Definition: sqlite3.c:63400

MEM_Blob

#define MEM_Blob

Definition: sqlite3.c:14704

Definition at line 70923 of file sqlite3.c.

#define SWAP	(	TYPE,
		A,
		B
	)	{TYPE t=A; A=B; B=t;}

Definition at line 8897 of file sqlite3.c.

#define swapMixedEndianFloat ( X )

Definition at line 67796 of file sqlite3.c.

#define TEMP_MASTER_NAME "sqlite_temp_master"

Definition at line 9182 of file sqlite3.c.

#define TERM_ANDINFO 0x20 /* Need to free the WhereTerm.u.pAndInfo obj */

Definition at line 116004 of file sqlite3.c.

#define TERM_CODED 0x04 /* This term is already coded */

Definition at line 116001 of file sqlite3.c.

#define TERM_COPIED 0x08 /* Has a child */

Definition at line 116002 of file sqlite3.c.

#define TERM_DYNAMIC 0x01 /* Need to call sqlite3ExprDelete(db, pExpr) */

Definition at line 115999 of file sqlite3.c.

#define TERM_LIKE 0x400 /* The original LIKE operator */

Definition at line 116013 of file sqlite3.c.

#define TERM_LIKECOND 0x200 /* Conditionally this LIKE operator term */

Definition at line 116012 of file sqlite3.c.

#define TERM_LIKEOPT 0x100 /* Virtual terms from the LIKE optimization */

Definition at line 116011 of file sqlite3.c.

#define TERM_OR_OK 0x40 /* Used during OR-clause processing */

Definition at line 116005 of file sqlite3.c.

#define TERM_ORINFO 0x10 /* Need to free the WhereTerm.u.pOrInfo object */

Definition at line 116003 of file sqlite3.c.

#define TERM_VIRTUAL 0x02 /* Added by the optimizer. Do not code */

Definition at line 116000 of file sqlite3.c.

#define TERM_VNULL 0x00 /* Disabled if not using stat3 */

Definition at line 116009 of file sqlite3.c.

#define TESTBIT	(	V,
		I
	)	(V[I>>3]&(1<<(I&7)))!=0

Definition at line 39178 of file sqlite3.c.

#define testcase ( X )

Definition at line 8458 of file sqlite3.c.

#define TESTONLY ( X )

Definition at line 8469 of file sqlite3.c.

#define TF_Autoincrement 0x08 /* Integer primary key is autoincrement */

Definition at line 11551 of file sqlite3.c.

#define TF_Ephemeral 0x02 /* An ephemeral table */

Definition at line 11549 of file sqlite3.c.

#define TF_HasPrimaryKey 0x04 /* Table has a primary key */

Definition at line 11550 of file sqlite3.c.

#define TF_OOOHidden 0x40 /* Out-of-Order hidden columns */

Definition at line 11554 of file sqlite3.c.

#define TF_Readonly 0x01 /* Read-only system table */

Definition at line 11548 of file sqlite3.c.

#define TF_Virtual 0x10 /* Is a virtual table */

Definition at line 11552 of file sqlite3.c.

#define TF_WithoutRowid 0x20 /* No rowid used. PRIMARY KEY is the key */

Definition at line 11553 of file sqlite3.c.

#define threadid pthread_self()

Definition at line 25758 of file sqlite3.c.

#define THREE_BYTE_INT ( x ) (65536*(i8)((x)[0])|((x)[1]<<8)|(x)[2])

Definition at line 67853 of file sqlite3.c.

#define TIMER_ELAPSED ((sqlite_uint64)0)

Definition at line 25678 of file sqlite3.c.

#define TIMER_END

Definition at line 25677 of file sqlite3.c.

#define TIMER_START

Definition at line 25676 of file sqlite3.c.

#define TK_ABORT 29

Definition at line 8660 of file sqlite3.c.

#define TK_ACTION 30

Definition at line 8661 of file sqlite3.c.

#define TK_ADD 142

Definition at line 8773 of file sqlite3.c.

#define TK_AFTER 31

Definition at line 8662 of file sqlite3.c.

#define TK_AGG_COLUMN 156

Definition at line 8787 of file sqlite3.c.

#define TK_AGG_FUNCTION 155

Definition at line 8786 of file sqlite3.c.

#define TK_ALL 116

Definition at line 8747 of file sqlite3.c.

#define TK_ALTER 141

Definition at line 8772 of file sqlite3.c.

#define TK_ANALYZE 32

Definition at line 8663 of file sqlite3.c.

#define TK_AND 72

Definition at line 8703 of file sqlite3.c.

#define TK_ANY 70

Definition at line 8701 of file sqlite3.c.

#define TK_AS 24

Definition at line 8655 of file sqlite3.c.

#define TK_ASC 33

Definition at line 8664 of file sqlite3.c.

#define TK_ATTACH 34

Definition at line 8665 of file sqlite3.c.

#define TK_AUTOINCR 106

Definition at line 8737 of file sqlite3.c.

#define TK_BEFORE 35

Definition at line 8666 of file sqlite3.c.

#define TK_BEGIN 5

Definition at line 8636 of file sqlite3.c.

#define TK_BETWEEN 74

Definition at line 8705 of file sqlite3.c.

#define TK_BITAND 85

Definition at line 8716 of file sqlite3.c.

#define TK_BITNOT 96

Definition at line 8727 of file sqlite3.c.

#define TK_BITOR 86

Definition at line 8717 of file sqlite3.c.

#define TK_BLOB 134

Definition at line 8765 of file sqlite3.c.

#define TK_BY 36

Definition at line 8667 of file sqlite3.c.

#define TK_CASCADE 37

Definition at line 8668 of file sqlite3.c.

#define TK_CASE 136

Definition at line 8767 of file sqlite3.c.

#define TK_CAST 38

Definition at line 8669 of file sqlite3.c.

#define TK_CHECK 104

Definition at line 8735 of file sqlite3.c.

#define TK_COLLATE 95

Definition at line 8726 of file sqlite3.c.

#define TK_COLUMN 154

Definition at line 8785 of file sqlite3.c.

#define TK_COLUMNKW 39

Definition at line 8670 of file sqlite3.c.

#define TK_COMMA 26

Definition at line 8657 of file sqlite3.c.

#define TK_COMMIT 10

Definition at line 8641 of file sqlite3.c.

#define TK_CONCAT 94

Definition at line 8725 of file sqlite3.c.

#define TK_CONFLICT 40

Definition at line 8671 of file sqlite3.c.

#define TK_CONSTRAINT 99

Definition at line 8730 of file sqlite3.c.

#define TK_CREATE 17

Definition at line 8648 of file sqlite3.c.

#define TK_CTIME_KW 69

Definition at line 8700 of file sqlite3.c.

#define TK_DATABASE 41

Definition at line 8672 of file sqlite3.c.

#define TK_DEFAULT 100

Definition at line 8731 of file sqlite3.c.

#define TK_DEFERRABLE 112

Definition at line 8743 of file sqlite3.c.

#define TK_DEFERRED 7

Definition at line 8638 of file sqlite3.c.

#define TK_DELETE 109

Definition at line 8740 of file sqlite3.c.

#define TK_DESC 42

Definition at line 8673 of file sqlite3.c.

#define TK_DETACH 43

Definition at line 8674 of file sqlite3.c.

#define TK_DISTINCT 121

Definition at line 8752 of file sqlite3.c.

#define TK_DOT 122

Definition at line 8753 of file sqlite3.c.

#define TK_DROP 114

Definition at line 8745 of file sqlite3.c.

#define TK_EACH 44

Definition at line 8675 of file sqlite3.c.

#define TK_ELSE 139

Definition at line 8770 of file sqlite3.c.

#define TK_END 11

Definition at line 8642 of file sqlite3.c.

#define TK_END_OF_FILE 149

Definition at line 8780 of file sqlite3.c.

#define TK_EQ 79

Definition at line 8710 of file sqlite3.c.

#define TK_ESCAPE 84

Definition at line 8715 of file sqlite3.c.

#define TK_EXCEPT 117

Definition at line 8748 of file sqlite3.c.

#define TK_EXCLUSIVE 9

Definition at line 8640 of file sqlite3.c.

#define TK_EXISTS 20

Definition at line 8651 of file sqlite3.c.

#define TK_EXPLAIN 2

Definition at line 8633 of file sqlite3.c.

#define TK_FAIL 45

Definition at line 8676 of file sqlite3.c.

#define TK_FLOAT 133

Definition at line 8764 of file sqlite3.c.

#define TK_FOR 46

Definition at line 8677 of file sqlite3.c.

#define TK_FOREIGN 113

Definition at line 8744 of file sqlite3.c.

#define TK_FROM 123

Definition at line 8754 of file sqlite3.c.

#define TK_FUNCTION 153

Definition at line 8784 of file sqlite3.c.

#define TK_GE 83

Definition at line 8714 of file sqlite3.c.

#define TK_GROUP 127

Definition at line 8758 of file sqlite3.c.

#define TK_GT 80

Definition at line 8711 of file sqlite3.c.

#define TK_HAVING 128

Definition at line 8759 of file sqlite3.c.

#define TK_ID 27

Definition at line 8658 of file sqlite3.c.

#define TK_IF 18

Definition at line 8649 of file sqlite3.c.

#define TK_IGNORE 47

Definition at line 8678 of file sqlite3.c.

#define TK_ILLEGAL 150

Definition at line 8781 of file sqlite3.c.

#define TK_IMMEDIATE 8

Definition at line 8639 of file sqlite3.c.

#define TK_IN 75

Definition at line 8706 of file sqlite3.c.

#define TK_INDEX 140

Definition at line 8771 of file sqlite3.c.

#define TK_INDEXED 28

Definition at line 8659 of file sqlite3.c.

#define TK_INITIALLY 48

Definition at line 8679 of file sqlite3.c.

#define TK_INSERT 108

Definition at line 8739 of file sqlite3.c.

#define TK_INSTEAD 49

Definition at line 8680 of file sqlite3.c.

#define TK_INTEGER 132

Definition at line 8763 of file sqlite3.c.

#define TK_INTERSECT 118

Definition at line 8749 of file sqlite3.c.

#define TK_INTO 131

Definition at line 8762 of file sqlite3.c.

#define TK_IS 73

Definition at line 8704 of file sqlite3.c.

#define TK_ISNOT 148

Definition at line 8779 of file sqlite3.c.

#define TK_ISNULL 76

Definition at line 8707 of file sqlite3.c.

#define TK_JOIN 124

Definition at line 8755 of file sqlite3.c.

#define TK_JOIN_KW 98

Definition at line 8729 of file sqlite3.c.

#define TK_KEY 53

Definition at line 8684 of file sqlite3.c.

#define TK_LE 81

Definition at line 8712 of file sqlite3.c.

#define TK_LIKE_KW 50

Definition at line 8681 of file sqlite3.c.

#define TK_LIMIT 129

Definition at line 8760 of file sqlite3.c.

#define TK_LP 22

Definition at line 8653 of file sqlite3.c.

#define TK_LSHIFT 87

Definition at line 8718 of file sqlite3.c.

#define TK_LT 82

Definition at line 8713 of file sqlite3.c.

#define TK_MATCH 51

Definition at line 8682 of file sqlite3.c.

#define TK_MINUS 90

Definition at line 8721 of file sqlite3.c.

#define TK_NE 78

Definition at line 8709 of file sqlite3.c.

#define TK_NO 52

Definition at line 8683 of file sqlite3.c.

#define TK_NOT 19

Definition at line 8650 of file sqlite3.c.

#define TK_NOTNULL 77

Definition at line 8708 of file sqlite3.c.

#define TK_NULL 101

Definition at line 8732 of file sqlite3.c.

#define TK_OF 54

Definition at line 8685 of file sqlite3.c.

#define TK_OFFSET 55

Definition at line 8686 of file sqlite3.c.

#define TK_ON 107

Definition at line 8738 of file sqlite3.c.

#define TK_OR 71

Definition at line 8702 of file sqlite3.c.

#define TK_ORDER 126

Definition at line 8757 of file sqlite3.c.

#define TK_PLAN 4

Definition at line 8635 of file sqlite3.c.

#define TK_PLUS 89

Definition at line 8720 of file sqlite3.c.

#define TK_PRAGMA 56

Definition at line 8687 of file sqlite3.c.

#define TK_PRIMARY 102

Definition at line 8733 of file sqlite3.c.

#define TK_QUERY 3

Definition at line 8634 of file sqlite3.c.

#define TK_RAISE 57

Definition at line 8688 of file sqlite3.c.

#define TK_RECURSIVE 58

Definition at line 8689 of file sqlite3.c.

#define TK_REFERENCES 105

Definition at line 8736 of file sqlite3.c.

#define TK_REGISTER 159

Definition at line 8790 of file sqlite3.c.

#define TK_REINDEX 67

Definition at line 8698 of file sqlite3.c.

#define TK_RELEASE 14

Definition at line 8645 of file sqlite3.c.

#define TK_REM 93

Definition at line 8724 of file sqlite3.c.

#define TK_RENAME 68

Definition at line 8699 of file sqlite3.c.

#define TK_REPLACE 59

Definition at line 8690 of file sqlite3.c.

#define TK_RESTRICT 60

Definition at line 8691 of file sqlite3.c.

#define TK_ROLLBACK 12

Definition at line 8643 of file sqlite3.c.

#define TK_ROW 61

Definition at line 8692 of file sqlite3.c.

#define TK_RP 23

Definition at line 8654 of file sqlite3.c.

#define TK_RSHIFT 88

Definition at line 8719 of file sqlite3.c.

#define TK_SAVEPOINT 13

Definition at line 8644 of file sqlite3.c.

#define TK_SELECT 119

Definition at line 8750 of file sqlite3.c.

#define TK_SEMI 1

Definition at line 8632 of file sqlite3.c.

#define TK_SET 111

Definition at line 8742 of file sqlite3.c.

#define TK_SLASH 92

Definition at line 8723 of file sqlite3.c.

#define TK_SPACE 151

Definition at line 8782 of file sqlite3.c.

#define TK_STAR 91

Definition at line 8722 of file sqlite3.c.

#define TK_STRING 97

Definition at line 8728 of file sqlite3.c.

#define TK_TABLE 16

Definition at line 8647 of file sqlite3.c.

#define TK_TEMP 21

Definition at line 8652 of file sqlite3.c.

#define TK_THEN 138

Definition at line 8769 of file sqlite3.c.

#define TK_TO 15

Definition at line 8646 of file sqlite3.c.

#define TK_TO_BLOB 144

Definition at line 8775 of file sqlite3.c.

#define TK_TO_INT 146

Definition at line 8777 of file sqlite3.c.

#define TK_TO_NUMERIC 145

Definition at line 8776 of file sqlite3.c.

#define TK_TO_REAL 147

Definition at line 8778 of file sqlite3.c.

#define TK_TO_TEXT 143

Definition at line 8774 of file sqlite3.c.

#define TK_TRANSACTION 6

Definition at line 8637 of file sqlite3.c.

#define TK_TRIGGER 62

Definition at line 8693 of file sqlite3.c.

#define TK_UMINUS 157

Definition at line 8788 of file sqlite3.c.

#define TK_UNCLOSED_STRING 152

Definition at line 8783 of file sqlite3.c.

#define TK_UNION 115

Definition at line 8746 of file sqlite3.c.

#define TK_UNIQUE 103

Definition at line 8734 of file sqlite3.c.

#define TK_UPDATE 110

Definition at line 8741 of file sqlite3.c.

#define TK_UPLUS 158

Definition at line 8789 of file sqlite3.c.

#define TK_USING 125

Definition at line 8756 of file sqlite3.c.

#define TK_VACUUM 63

Definition at line 8694 of file sqlite3.c.

#define TK_VALUES 120

Definition at line 8751 of file sqlite3.c.

#define TK_VARIABLE 135

Definition at line 8766 of file sqlite3.c.

#define TK_VIEW 64

Definition at line 8695 of file sqlite3.c.

#define TK_VIRTUAL 65

Definition at line 8696 of file sqlite3.c.

#define TK_WHEN 137

Definition at line 8768 of file sqlite3.c.

#define TK_WHERE 130

Definition at line 8761 of file sqlite3.c.

#define TK_WITH 66

Definition at line 8697 of file sqlite3.c.

#define TK_WITHOUT 25

Definition at line 8656 of file sqlite3.c.

#define tkCREATE 4

Definition at line 127659 of file sqlite3.c.

#define tkEND 7

Definition at line 127662 of file sqlite3.c.

#define tkEXPLAIN 3

Definition at line 127658 of file sqlite3.c.

#define tkOTHER 2

Definition at line 127656 of file sqlite3.c.

#define tkSEMI 0

Definition at line 127654 of file sqlite3.c.

#define tkTEMP 5

Definition at line 127660 of file sqlite3.c.

#define tkTRIGGER 6

Definition at line 127661 of file sqlite3.c.

#define tkWS 1

Definition at line 127655 of file sqlite3.c.

#define TOKEN (yyminor.yy0)

#define TRACE ( X )

Definition at line 53114 of file sqlite3.c.

#define TRACE_IDX_INPUTS ( A )

Definition at line 117845 of file sqlite3.c.

#define TRACE_IDX_OUTPUTS ( A )

Definition at line 117846 of file sqlite3.c.

#define TRANS_NONE 0

Definition at line 52482 of file sqlite3.c.

#define TRANS_READ 1

Definition at line 52483 of file sqlite3.c.

#define TRANS_WRITE 2

Definition at line 52484 of file sqlite3.c.

#define TRIGGER_AFTER 2

Definition at line 12676 of file sqlite3.c.

#define TRIGGER_BEFORE 1

Definition at line 12675 of file sqlite3.c.

#define TWO_BYTE_INT ( x ) (256*(i8)((x)[0])|(x)[1])

Definition at line 67852 of file sqlite3.c.

#define TWOPOWER31 (((i64)1)<<31)

Definition at line 24664 of file sqlite3.c.

#define TWOPOWER32 (((i64)1)<<32)

Definition at line 24663 of file sqlite3.c.

#define UINT16_TYPE unsigned short int

Definition at line 8927 of file sqlite3.c.

#define UINT32_TYPE unsigned int

Definition at line 8920 of file sqlite3.c.

#define UINT8_TYPE unsigned char

Definition at line 8941 of file sqlite3.c.

#define UNIX_SHM_BASE ((22+SQLITE_SHM_NLOCK)*4) /* first lock byte */

Definition at line 29566 of file sqlite3.c.

#define UNIX_SHM_DMS (UNIX_SHM_BASE+SQLITE_SHM_NLOCK) /* deadman switch */

Definition at line 29567 of file sqlite3.c.

#define UNIXFILE_BLOCK 0x0200 /* Next SHM lock might block */

Definition at line 25521 of file sqlite3.c.

#define UNIXFILE_DELETE 0x20 /* Delete on close */

Definition at line 25517 of file sqlite3.c.

#define UNIXFILE_DIRSYNC 0x08 /* Directory sync needed */

Definition at line 25512 of file sqlite3.c.

#define UNIXFILE_EXCL 0x01 /* Connections from one process only */

Definition at line 25508 of file sqlite3.c.

#define UNIXFILE_NOLOCK 0x80 /* Do no file locking */

Definition at line 25519 of file sqlite3.c.

#define UNIXFILE_PERSIST_WAL 0x04 /* Persistent WAL mode */

Definition at line 25510 of file sqlite3.c.

#define UNIXFILE_PSOW 0x10 /* SQLITE_IOCAP_POWERSAFE_OVERWRITE */

Definition at line 25516 of file sqlite3.c.

#define UNIXFILE_RDONLY 0x02 /* Connection is read only */

Definition at line 25509 of file sqlite3.c.

#define UNIXFILE_URI 0x40 /* Filename might have query parameters */

Definition at line 25518 of file sqlite3.c.

#define UNIXFILE_WARNED 0x0100 /* verifyDbFile() warnings issued */

Definition at line 25520 of file sqlite3.c.

#define unixLogError	(	a,
		b,
		c
	)	unixLogErrorAtLine(a,b,c,__LINE__)

Definition at line 26580 of file sqlite3.c.

#define UNIXVFS	(	VFSNAME,
		FINDER
	)

Value:

{                        \
    3,                    /* iVersion */                    \
    sizeof(unixFile),     /* szOsFile */                    \
    MAX_PATHNAME,         /* mxPathname */                  \
    0,                    /* pNext */                       \
    VFSNAME,              /* zName */                       \
    (void*)&FINDER,       /* pAppData */                    \
    unixOpen,             /* xOpen */                       \
    unixDelete,           /* xDelete */                     \
    unixAccess,           /* xAccess */                     \
    unixFullPathname,     /* xFullPathname */               \
    unixDlOpen,           /* xDlOpen */                     \
    unixDlError,          /* xDlError */                    \
    unixDlSym,            /* xDlSym */                      \
    unixDlClose,          /* xDlClose */                    \
    unixRandomness,       /* xRandomness */                 \
    unixSleep,            /* xSleep */                      \
    unixCurrentTime,      /* xCurrentTime */                \
    unixGetLastError,     /* xGetLastError */               \
    unixCurrentTimeInt64, /* xCurrentTimeInt64 */           \
    unixSetSystemCall,    /* xSetSystemCall */              \
    unixGetSystemCall,    /* xGetSystemCall */              \
    unixNextSystemCall,   /* xNextSystemCall */             \
  }

#define UNKNOWN_LOCK (EXCLUSIVE_LOCK+1)

Definition at line 42070 of file sqlite3.c.

#define unlikely ( X ) (X)

Definition at line 8527 of file sqlite3.c.

#define UNUSED_PARAMETER ( x ) (void)(x)

Definition at line 9257 of file sqlite3.c.

#define UNUSED_PARAMETER2	(	x,
		y
	)	UNUSED_PARAMETER(x),UNUSED_PARAMETER(y)

Definition at line 9258 of file sqlite3.c.

#define UPDATE_MAX_BLOBSIZE ( P )

Definition at line 70882 of file sqlite3.c.

#define UpperToLower sqlite3UpperToLower

Definition at line 23679 of file sqlite3.c.

#define USEFETCH ( x ) 0

Definition at line 42454 of file sqlite3.c.

#define valueFromFunction	(	a,
		b,
		c,
		d,
		e,
		f
	)	SQLITE_OK

Definition at line 64359 of file sqlite3.c.

#define VDBE_MAGIC_DEAD 0xb606c3c8 /* The VDBE has been deallocated */

Definition at line 14888 of file sqlite3.c.

#define VDBE_MAGIC_HALT 0x519c2973 /* VDBE has completed execution */

Definition at line 14887 of file sqlite3.c.

#define VDBE_MAGIC_INIT 0x26bceaa5 /* Building a VDBE program */

Definition at line 14885 of file sqlite3.c.

#define VDBE_MAGIC_RUN 0xbdf20da3 /* VDBE is ready to execute */

Definition at line 14886 of file sqlite3.c.

#define VDBE_OFFSET_LINENO ( x ) 0

Definition at line 10074 of file sqlite3.c.

#define vdbeAssertFieldCountWithinLimits	(	A,
		B,
		C
	)

Definition at line 68205 of file sqlite3.c.

#define VdbeBranchTaken	(	I,
		M
	)

Definition at line 70902 of file sqlite3.c.

#define VdbeComment ( X )

Definition at line 10035 of file sqlite3.c.

#define VdbeCoverage ( v )

Definition at line 10070 of file sqlite3.c.

#define VdbeCoverageAlwaysTaken ( v )

Definition at line 10072 of file sqlite3.c.

#define VdbeCoverageIf	(	v,
		x
	)

Definition at line 10071 of file sqlite3.c.

#define VdbeCoverageNeverTaken ( v )

Definition at line 10073 of file sqlite3.c.

#define VdbeFrameMem ( p ) ((Mem *)&((u8 *)p)[ROUND8(sizeof(VdbeFrame))])

Definition at line 14651 of file sqlite3.c.

#define vdbeInvokeSqllog ( x )

Definition at line 67382 of file sqlite3.c.

#define VdbeMemDynamic ( X ) (((X)->flags&(MEM_Agg|MEM_Dyn|MEM_RowSet|MEM_Frame))!=0)

Definition at line 14940 of file sqlite3.c.

#define VdbeModuleComment ( X )

Definition at line 10037 of file sqlite3.c.

#define VdbeNoopComment ( X )

Definition at line 10036 of file sqlite3.c.

#define vdbeSorterBlockDebug	(	x,
		y,
		z
	)

Definition at line 79022 of file sqlite3.c.

#define vdbeSorterExtendFile	(	x,
		y,
		z
	)

Definition at line 79211 of file sqlite3.c.

#define vdbeSorterPopulateDebug	(	x,
		y
	)

Definition at line 79021 of file sqlite3.c.

#define vdbeSorterRewindDebug ( y )

Definition at line 79020 of file sqlite3.c.

#define vdbeSorterWorkDebug	(	x,
		y
	)

Definition at line 79019 of file sqlite3.c.

#define vfsList GLOBAL(sqlite3_vfs *, vfsList)

Definition at line 16769 of file sqlite3.c.

#define VFUNCTION	(	zName,
		nArg,
		iArg,
		bNC,
		xFunc
	)

Value:

{nArg, SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \

SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, #zName, 0, 0}

SQLITE_UTF8

#define SQLITE_UTF8

Definition: sqlite3.c:4463

SQLITE_INT_TO_PTR

#define SQLITE_INT_TO_PTR(X)

Definition: sqlite3.c:8306

SQLITE_FUNC_NEEDCOLL

#define SQLITE_FUNC_NEEDCOLL

Definition: sqlite3.c:11244

Definition at line 11284 of file sqlite3.c.

#define VVA_ONLY ( X )

Definition at line 8483 of file sqlite3.c.

#define WAL_ALL_BUT_WRITE 1

Definition at line 49211 of file sqlite3.c.

#define WAL_CKPT_LOCK 1

Definition at line 49212 of file sqlite3.c.

#define WAL_EXCLUSIVE_MODE 1

Definition at line 49375 of file sqlite3.c.

#define WAL_FRAME_HDRSIZE 24

Definition at line 49314 of file sqlite3.c.

#define WAL_HDRSIZE 32

Definition at line 49318 of file sqlite3.c.

#define WAL_HEAPMEMORY_MODE 2

Definition at line 49376 of file sqlite3.c.

#define WAL_MAGIC 0x377f0682

Definition at line 49329 of file sqlite3.c.

#define WAL_MAX_VERSION 3007000

Definition at line 49203 of file sqlite3.c.

#define WAL_NORMAL_MODE 0

Definition at line 49374 of file sqlite3.c.

#define WAL_NREADER (SQLITE_SHM_NLOCK-3)

Definition at line 49215 of file sqlite3.c.

#define WAL_RDONLY 1 /* The WAL file is readonly */

Definition at line 49382 of file sqlite3.c.

#define WAL_RDWR 0 /* Normal read/write connection */

Definition at line 49381 of file sqlite3.c.

#define WAL_READ_LOCK ( I ) (3+(I))

Definition at line 49214 of file sqlite3.c.

#define WAL_RECOVER_LOCK 2

Definition at line 49213 of file sqlite3.c.

#define WAL_RETRY (-1)

Definition at line 51021 of file sqlite3.c.

#define WAL_SAVEPOINT_NDATA 4

Definition at line 41595 of file sqlite3.c.

#define WAL_SHM_RDONLY 2 /* The SHM file is readonly */

Definition at line 49383 of file sqlite3.c.

#define WAL_SYNC_TRANSACTIONS 0x20 /* Sync at the end of each transaction */

Definition at line 41571 of file sqlite3.c.

#define WAL_WRITE_LOCK 0

Definition at line 49210 of file sqlite3.c.

#define walFrameOffset	(	iFrame,
		szPage
	)

Value:

(                               \
  WAL_HDRSIZE + ((iFrame)-1)*(i64)((szPage)+WAL_FRAME_HDRSIZE)         \
)

Definition at line 49336 of file sqlite3.c.

#define WALINDEX_HDR_SIZE (WALINDEX_LOCK_OFFSET+WALINDEX_LOCK_RESERVED)

Definition at line 49311 of file sqlite3.c.

#define WALINDEX_LOCK_OFFSET (sizeof(WalIndexHdr)*2 + sizeof(WalCkptInfo))

Definition at line 49309 of file sqlite3.c.

#define WALINDEX_LOCK_RESERVED 16

Definition at line 49310 of file sqlite3.c.

#define WALINDEX_MAX_VERSION 3007000

Definition at line 49204 of file sqlite3.c.

#define WALINDEX_PGSZ

Value:

(                                         \
    sizeof(ht_slot)*HASHTABLE_NSLOT + HASHTABLE_NPAGE*sizeof(u32) \
)

Definition at line 49438 of file sqlite3.c.

#define WALTRACE ( X )

Definition at line 49187 of file sqlite3.c.

#define WHERE_AUTO_INDEX 0x00004000 /* Uses an ephemeral index */

Definition at line 116198 of file sqlite3.c.

#define WHERE_BOTH_LIMIT 0x00000030 /* Both x>EXPR and x<EXPR */

Definition at line 116190 of file sqlite3.c.

#define WHERE_BTM_LIMIT 0x00000020 /* x>EXPR or x>=EXPR constraint */

Definition at line 116189 of file sqlite3.c.

#define WHERE_COLUMN_EQ 0x00000001 /* x=EXPR */

Definition at line 116183 of file sqlite3.c.

#define WHERE_COLUMN_IN 0x00000004 /* x IN (...) */

Definition at line 116185 of file sqlite3.c.

#define WHERE_COLUMN_NULL 0x00000008 /* x IS NULL */

Definition at line 116186 of file sqlite3.c.

#define WHERE_COLUMN_RANGE 0x00000002 /* x<EXPR and/or x>EXPR */

Definition at line 116184 of file sqlite3.c.

#define WHERE_CONSTRAINT 0x0000000f /* Any of the WHERE_COLUMN_xxx values */

Definition at line 116187 of file sqlite3.c.

#define WHERE_DISTINCT_NOOP 0 /* DISTINCT keyword not used */

Definition at line 12206 of file sqlite3.c.

#define WHERE_DISTINCT_ORDERED 2 /* All duplicates are adjacent */

Definition at line 12208 of file sqlite3.c.

#define WHERE_DISTINCT_UNIQUE 1 /* No duplicates */

Definition at line 12207 of file sqlite3.c.

#define WHERE_DISTINCT_UNORDERED 3 /* Duplicates are scattered */

Definition at line 12209 of file sqlite3.c.

#define WHERE_DISTINCTBY 0x0200 /* pOrderby is really a DISTINCT clause */

Definition at line 12199 of file sqlite3.c.

#define WHERE_DUPLICATES_OK 0x0008 /* Ok to return a row more than once */

Definition at line 12193 of file sqlite3.c.

#define WHERE_FORCE_TABLE 0x0020 /* Do not use an index-only search */

Definition at line 12195 of file sqlite3.c.

#define WHERE_GROUPBY 0x0100 /* pOrderBy is really a GROUP BY */

Definition at line 12198 of file sqlite3.c.

#define WHERE_IDX_ONLY 0x00000040 /* Use index only - omit table */

Definition at line 116191 of file sqlite3.c.

#define WHERE_IN_ABLE 0x00000800 /* Able to support an IN operator */

Definition at line 116195 of file sqlite3.c.

#define WHERE_INDEXED 0x00000200 /* WhereLoop.u.btree.pIndex is valid */

Definition at line 116193 of file sqlite3.c.

#define WHERE_IPK 0x00000100 /* x is the INTEGER PRIMARY KEY */

Definition at line 116192 of file sqlite3.c.

#define WHERE_LOOP_XFER_SZ offsetof(WhereLoop,nLSlot)

Definition at line 115868 of file sqlite3.c.

#define WHERE_MULTI_OR 0x00002000 /* OR using multiple indices */

Definition at line 116197 of file sqlite3.c.

#define WHERE_NO_AUTOINDEX 0x0080 /* Disallow automatic indexes */

Definition at line 12197 of file sqlite3.c.

#define WHERE_OMIT_OPEN_CLOSE 0x0010 /* Table cursors are already open */

Definition at line 12194 of file sqlite3.c.

#define WHERE_ONEPASS_DESIRED 0x0004 /* Want to do one-pass UPDATE/DELETE */

Definition at line 12192 of file sqlite3.c.

#define WHERE_ONEROW 0x00001000 /* Selects no more than one row */

Definition at line 116196 of file sqlite3.c.

#define WHERE_ONETABLE_ONLY 0x0040 /* Only code the 1st table in pTabList */

Definition at line 12196 of file sqlite3.c.

#define WHERE_ORDERBY_MAX 0x0002 /* ORDER BY processing for max() func */

Definition at line 12191 of file sqlite3.c.

#define WHERE_ORDERBY_MIN 0x0001 /* ORDER BY processing for min() func */

Definition at line 12190 of file sqlite3.c.

#define WHERE_ORDERBY_NORMAL 0x0000 /* No-op */

Definition at line 12189 of file sqlite3.c.

#define WHERE_PARTIALIDX 0x00020000 /* The automatic index is partial */

Definition at line 116201 of file sqlite3.c.

#define WHERE_REOPEN_IDX 0x1000 /* Try to use OP_ReopenIdx */

Definition at line 12202 of file sqlite3.c.

#define WHERE_SKIPSCAN 0x00008000 /* Uses the skip-scan algorithm */

Definition at line 116199 of file sqlite3.c.

#define WHERE_SORTBYGROUP 0x0800 /* Support sqlite3WhereIsSorted() */

Definition at line 12201 of file sqlite3.c.

#define WHERE_TOP_LIMIT 0x00000010 /* x<EXPR or x<=EXPR constraint */

Definition at line 116188 of file sqlite3.c.

#define WHERE_UNQ_WANTED 0x00010000 /* WHERE_ONEROW would have been helpful*/

Definition at line 116200 of file sqlite3.c.

#define WHERE_VIRTUALTABLE 0x00000400 /* WhereLoop.u.vtab is valid */

Definition at line 116194 of file sqlite3.c.

#define WHERE_WANT_DISTINCT 0x0400 /* All output needs to be distinct */

Definition at line 12200 of file sqlite3.c.

#define WHERETRACE	(	K,
		X
	)

Definition at line 115760 of file sqlite3.c.

#define WO_ALL 0xfff /* Mask of all possible WO_* values */

Definition at line 116175 of file sqlite3.c.

#define WO_AND 0x200 /* Two or more AND-connected terms */

Definition at line 116171 of file sqlite3.c.

#define WO_EQ 0x002

Definition at line 116163 of file sqlite3.c.

#define WO_EQUIV 0x400 /* Of the form A==B, both columns */

Definition at line 116172 of file sqlite3.c.

#define WO_GE (WO_EQ<<(TK_GE-TK_EQ))

Definition at line 116167 of file sqlite3.c.

#define WO_GT (WO_EQ<<(TK_GT-TK_EQ))

Definition at line 116166 of file sqlite3.c.

#define WO_IN 0x001

Definition at line 116162 of file sqlite3.c.

#define WO_ISNULL 0x080

Definition at line 116169 of file sqlite3.c.

#define WO_LE (WO_EQ<<(TK_LE-TK_EQ))

Definition at line 116165 of file sqlite3.c.

#define WO_LT (WO_EQ<<(TK_LT-TK_EQ))

Definition at line 116164 of file sqlite3.c.

#define WO_MATCH 0x040

Definition at line 116168 of file sqlite3.c.

#define WO_NOOP 0x800 /* This term does not restrict search space */

Definition at line 116173 of file sqlite3.c.

#define WO_OR 0x100 /* Two or more OR-connected terms */

Definition at line 116170 of file sqlite3.c.

#define WO_SINGLE 0x0ff /* Mask of all non-compound WO_* values */

Definition at line 116176 of file sqlite3.c.

#define WRC_Abort 2 /* Abandon the tree walk */

Definition at line 12882 of file sqlite3.c.

#define WRC_Continue 0 /* Continue down into children */

Definition at line 12880 of file sqlite3.c.

#define WRC_Prune 1 /* Omit children but continue walking siblings */

Definition at line 12881 of file sqlite3.c.

#define WRITE_LOCK 2

Definition at line 52436 of file sqlite3.c.

#define WRITE_UTF16BE	(	zOut,
		c
	)

Value:

{                                    \
  if( c<=0xFFFF ){                                                  \
    *zOut++ = (u8)((c>>8)&0x00FF);                                  \
    *zOut++ = (u8)(c&0x00FF);                                       \
  }else{                                                            \
    *zOut++ = (u8)(0x00D8 + (((c-0x10000)>>18)&0x03));              \
    *zOut++ = (u8)(((c>>10)&0x003F) + (((c-0x10000)>>10)&0x00C0));  \
    *zOut++ = (u8)(0x00DC + ((c>>8)&0x03));                         \
    *zOut++ = (u8)(c&0x00FF);                                       \
  }                                                                 \
}

Definition at line 23003 of file sqlite3.c.

#define WRITE_UTF16LE	(	zOut,
		c
	)

Value:

{                                    \
  if( c<=0xFFFF ){                                                  \
    *zOut++ = (u8)(c&0x00FF);                                       \
    *zOut++ = (u8)((c>>8)&0x00FF);                                  \
  }else{                                                            \
    *zOut++ = (u8)(((c>>10)&0x003F) + (((c-0x10000)>>10)&0x00C0));  \
    *zOut++ = (u8)(0x00D8 + (((c-0x10000)>>18)&0x03));              \
    *zOut++ = (u8)(c&0x00FF);                                       \
    *zOut++ = (u8)(0x00DC + ((c>>8)&0x03));                         \
  }                                                                 \
}

Definition at line 22991 of file sqlite3.c.

#define WRITE_UTF8	(	zOut,
		c
	)

Value:

{                          \
  if( c<0x00080 ){                                     \
    *zOut++ = (u8)(c&0xFF);                            \
  }                                                    \
  else if( c<0x00800 ){                                \
    *zOut++ = 0xC0 + (u8)((c>>6)&0x1F);                \
    *zOut++ = 0x80 + (u8)(c & 0x3F);                   \
  }                                                    \
  else if( c<0x10000 ){                                \
    *zOut++ = 0xE0 + (u8)((c>>12)&0x0F);               \
    *zOut++ = 0x80 + (u8)((c>>6) & 0x3F);              \
    *zOut++ = 0x80 + (u8)(c & 0x3F);                   \
  }else{                                               \
    *zOut++ = 0xF0 + (u8)((c>>18) & 0x07);             \
    *zOut++ = 0x80 + (u8)((c>>12) & 0x3F);             \
    *zOut++ = 0x80 + (u8)((c>>6) & 0x3F);              \
    *zOut++ = 0x80 + (u8)(c & 0x3F);                   \
  }                                                    \
}

Definition at line 22971 of file sqlite3.c.

#define wsdAutoext sqlite3Autoext

Definition at line 103003 of file sqlite3.c.

#define wsdAutoextInit

Definition at line 103002 of file sqlite3.c.

#define wsdHooks sqlite3Hooks

Definition at line 16911 of file sqlite3.c.

#define wsdHooksInit

Definition at line 16910 of file sqlite3.c.

#define wsdPrng sqlite3Prng

#define wsdStat sqlite3Stat

Definition at line 15042 of file sqlite3.c.

#define wsdStatInit

Definition at line 15041 of file sqlite3.c.

#define YY_ACCEPT_ACTION (YYNSTATE+YYNRULE+1)

Definition at line 123476 of file sqlite3.c.

#define YY_ACTTAB_COUNT (1497)

Definition at line 123543 of file sqlite3.c.

#define YY_ERROR_ACTION (YYNSTATE+YYNRULE)

Definition at line 123477 of file sqlite3.c.

#define YY_NO_ACTION (YYNSTATE+YYNRULE+2)

Definition at line 123475 of file sqlite3.c.

#define YY_REDUCE_COUNT (305)

Definition at line 123898 of file sqlite3.c.

#define YY_REDUCE_MAX (1323)

Definition at line 123900 of file sqlite3.c.

#define YY_REDUCE_MIN (-109)

Definition at line 123899 of file sqlite3.c.

#define YY_REDUCE_USE_DFLT (-110)

Definition at line 123897 of file sqlite3.c.

#define YY_SHIFT_COUNT (429)

Definition at line 123849 of file sqlite3.c.

#define YY_SHIFT_MAX (1383)

Definition at line 123851 of file sqlite3.c.

#define YY_SHIFT_MIN (-85)

Definition at line 123850 of file sqlite3.c.

#define YY_SHIFT_USE_DFLT (-86)

Definition at line 123848 of file sqlite3.c.

#define YYACTIONTYPE unsigned short int

Definition at line 123443 of file sqlite3.c.

#define YYCODETYPE unsigned char

Definition at line 123441 of file sqlite3.c.

#define YYFALLBACK 1

Definition at line 123474 of file sqlite3.c.

#define YYNOCODE 254

Definition at line 123442 of file sqlite3.c.

#define YYNOERRORRECOVERY 1

Definition at line 123256 of file sqlite3.c.

#define YYNRULE 327

Definition at line 123473 of file sqlite3.c.

#define YYNSTATE 642

Definition at line 123472 of file sqlite3.c.

#define YYSTACKDEPTH 100

Definition at line 123466 of file sqlite3.c.

#define yytestcase ( X ) testcase(X)

Definition at line 123261 of file sqlite3.c.

#define YYWILDCARD 70

Definition at line 123444 of file sqlite3.c.

Typedef Documentation

typedef unsigned bft

Definition at line 14797 of file sqlite3.c.

typedef u64 Bitmask

Definition at line 12111 of file sqlite3.c.

typedef unsigned Bool

Definition at line 14538 of file sqlite3.c.

typedef unsigned char etByte

Definition at line 21396 of file sqlite3.c.

typedef u16 ht_slot

Definition at line 49389 of file sqlite3.c.

typedef INT16_TYPE i16

Definition at line 8958 of file sqlite3.c.

typedef sqlite_int64 i64

Definition at line 8954 of file sqlite3.c.

typedef INT8_TYPE i8

Definition at line 8960 of file sqlite3.c.

typedef struct KeyClass KeyClass

Definition at line 9281 of file sqlite3.c.

typedef INT16_TYPE LogEst

Definition at line 9005 of file sqlite3.c.

typedef u32 Pgno

Definition at line 10121 of file sqlite3.c.

typedef int(* RecordCompare) (int, const void *, UnpackedRecord *)

Definition at line 10010 of file sqlite3.c.

typedef int(* SorterCompare) (SortSubtask *, int *, const void *, int, const void *, int)

Definition at line 78223 of file sqlite3.c.

typedef struct sqlite3_blob sqlite3_blob

Definition at line 5974 of file sqlite3.c.

typedef int(* sqlite3_callback) (void *, int, char **, char **)

Definition at line 528 of file sqlite3.c.

typedef void(* sqlite3_destructor_type) (void *)

Definition at line 4700 of file sqlite3.c.

typedef sqlite_int64 sqlite3_int64

Definition at line 467 of file sqlite3.c.

typedef struct sqlite3_pcache sqlite3_pcache

Definition at line 6917 of file sqlite3.c.

typedef double sqlite3_rtree_dbl

Definition at line 7954 of file sqlite3.c.

typedef struct sqlite3_stmt sqlite3_stmt

Definition at line 3302 of file sqlite3.c.

typedef void(* sqlite3_syscall_ptr) (void)

Definition at line 1375 of file sqlite3.c.

typedef sqlite_uint64 sqlite3_uint64

Definition at line 468 of file sqlite3.c.

typedef int(* sqlite3_xauth) (void *, int, const char *, const char *, const char *, const char *)

Definition at line 10983 of file sqlite3.c.

typedef long long int sqlite_int64

Definition at line 464 of file sqlite3.c.

typedef unsigned long long int sqlite_uint64

Definition at line 465 of file sqlite3.c.

typedef struct TreeView TreeView

Definition at line 9299 of file sqlite3.c.

typedef u32 tRowcnt

Definition at line 8979 of file sqlite3.c.

typedef UINT16_TYPE u16

Definition at line 8957 of file sqlite3.c.

typedef UINT32_TYPE u32

Definition at line 8956 of file sqlite3.c.

typedef sqlite_uint64 u64

Definition at line 8955 of file sqlite3.c.

typedef UINT8_TYPE u8

Definition at line 8959 of file sqlite3.c.

typedef unsigned int yDbMask

Definition at line 12475 of file sqlite3.c.

typedef i16 ynVar

Definition at line 11857 of file sqlite3.c.

Function Documentation

IOMETHODS	(	posixIoFinder	,
		posixIoMethods	,
		IOMETHODS(	3,
		unixClose	,
		unixLock	,
		unixUnlock	,
		unixCheckReservedLock	,
		unixShmMap
	)

Definition at line 30489 of file sqlite3.c.

  {
   static const struct Mapping {
     const char *zFilesystem;              /* Filesystem type name */
     const sqlite3_io_methods *pMethods;   /* Appropriate locking method */
   } aMap[] = {
     { "hfs",    &posixIoMethods },
     { "ufs",    &posixIoMethods },
     { "afpfs",  &afpIoMethods },
     { "smbfs",  &afpIoMethods },
     { "webdav", &nolockIoMethods },
     { 0, 0 }
   };
   int i;
   struct statfs fsInfo;
   struct flock lockInfo;
 
   if( !filePath ){
     /* If filePath==NULL that means we are dealing with a transient file
     ** that does not need to be locked. */
     return &nolockIoMethods;
   }
   if( statfs(filePath, &fsInfo) != -1 ){
     if( fsInfo.f_flags & MNT_RDONLY ){
       return &nolockIoMethods;
     }
     for(i=0; aMap[i].zFilesystem; i++){
       if( strcmp(fsInfo.f_fstypename, aMap[i].zFilesystem)==0 ){
         return aMap[i].pMethods;
       }
     }
   }
 
   /* Default case. Handles, amongst others, "nfs".
   ** Test byte-range lock using fcntl(). If the call succeeds, 
   ** assume that the file-system supports POSIX style locks. 
   */
   lockInfo.l_len = 1;
   lockInfo.l_start = 0;
   lockInfo.l_whence = SEEK_SET;
   lockInfo.l_type = F_RDLCK;
   if( osFcntl(pNew->h, F_GETLK, &lockInfo)!=-1 ) {
     if( strcmp(fsInfo.f_fstypename, "nfs")==0 ){
       return &nfsIoMethods;
     } else {
       return &posixIoMethods;
     }
   }else{
     return &dotlockIoMethods;
   }
 }
 static const sqlite3_io_methods 
   *(*const autolockIoFinder)(const char*,unixFile*) = autolockIoFinderImpl;
 
 #endif /* defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE */
 
 #if OS_VXWORKS
 /*
 ** This "finder" function for VxWorks checks to see if posix advisory
 ** locking works.  If it does, then that is what is used.  If it does not
 ** work, then fallback to named semaphore locking.
 */
 static const sqlite3_io_methods *vxworksIoFinderImpl(
   const char *filePath,    /* name of the database file */
   unixFile *pNew           /* the open file object */
 ){
   struct flock lockInfo;
 
   if( !filePath ){
     /* If filePath==NULL that means we are dealing with a transient file
     ** that does not need to be locked. */
     return &nolockIoMethods;
   }
 
   /* Test if fcntl() is supported and use POSIX style locks.
   ** Otherwise fall back to the named semaphore method.
   */
   lockInfo.l_len = 1;
   lockInfo.l_start = 0;
   lockInfo.l_whence = SEEK_SET;
   lockInfo.l_type = F_RDLCK;
   if( osFcntl(pNew->h, F_GETLK, &lockInfo)!=-1 ) {
     return &posixIoMethods;
   }else{
     return &semIoMethods;
   }
 }
 static const sqlite3_io_methods 
   *(*const vxworksIoFinder)(const char*,unixFile*) = vxworksIoFinderImpl;
 
 #endif /* OS_VXWORKS */
 
 /*
 ** An abstract type for a pointer to an IO method finder function:
 */
 typedef const sqlite3_io_methods *(*finder_type)(const char*,unixFile*);
 
 
 /****************************************************************************
 **************************** sqlite3_vfs methods ****************************
 **
 ** This division contains the implementation of methods on the
 ** sqlite3_vfs object.
 */
 
 /*
 ** Initialize the contents of the unixFile structure pointed to by pId.
 */
 static int fillInUnixFile(
   sqlite3_vfs *pVfs,      /* Pointer to vfs object */
   int h,                  /* Open file descriptor of file being opened */
   sqlite3_file *pId,      /* Write to the unixFile structure here */
   const char *zFilename,  /* Name of the file being opened */
   int ctrlFlags           /* Zero or more UNIXFILE_* values */
 ){
   const sqlite3_io_methods *pLockingStyle;
   unixFile *pNew = (unixFile *)pId;
   int rc = SQLITE_OK;
 
   assert( pNew->pInode==NULL );
 
   /* Usually the path zFilename should not be a relative pathname. The
   ** exception is when opening the proxy "conch" file in builds that
   ** include the special Apple locking styles.
   */
 #if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE
   assert( zFilename==0 || zFilename[0]=='/' 
     || pVfs->pAppData==(void*)&autolockIoFinder );
 #else
   assert( zFilename==0 || zFilename[0]=='/' );
 #endif
 
   /* No locking occurs in temporary files */
   assert( zFilename!=0 || (ctrlFlags & UNIXFILE_NOLOCK)!=0 );
 
   OSTRACE(("OPEN    %-3d %s\n", h, zFilename));
   pNew->h = h;
   pNew->pVfs = pVfs;
   pNew->zPath = zFilename;
   pNew->ctrlFlags = (u8)ctrlFlags;
 #if SQLITE_MAX_MMAP_SIZE>0
   pNew->mmapSizeMax = sqlite3GlobalConfig.szMmap;
 #endif
   if( sqlite3_uri_boolean(((ctrlFlags & UNIXFILE_URI) ? zFilename : 0),
                            "psow", SQLITE_POWERSAFE_OVERWRITE) ){
     pNew->ctrlFlags |= UNIXFILE_PSOW;
   }
   if( strcmp(pVfs->zName,"unix-excl")==0 ){
     pNew->ctrlFlags |= UNIXFILE_EXCL;
   }
 
 #if OS_VXWORKS
   pNew->pId = vxworksFindFileId(zFilename);
   if( pNew->pId==0 ){
     ctrlFlags |= UNIXFILE_NOLOCK;
     rc = SQLITE_NOMEM;
   }
 #endif
 
   if( ctrlFlags & UNIXFILE_NOLOCK ){
     pLockingStyle = &nolockIoMethods;
   }else{
     pLockingStyle = (**(finder_type*)pVfs->pAppData)(zFilename, pNew);
 #if SQLITE_ENABLE_LOCKING_STYLE
     /* Cache zFilename in the locking context (AFP and dotlock override) for
     ** proxyLock activation is possible (remote proxy is based on db name)
     ** zFilename remains valid until file is closed, to support */
     pNew->lockingContext = (void*)zFilename;
 #endif
   }
 
   if( pLockingStyle == &posixIoMethods
 #if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE
     || pLockingStyle == &nfsIoMethods
 #endif
   ){
     unixEnterMutex();
     rc = findInodeInfo(pNew, &pNew->pInode);
     if( rc!=SQLITE_OK ){
       /* If an error occurred in findInodeInfo(), close the file descriptor
       ** immediately, before releasing the mutex. findInodeInfo() may fail
       ** in two scenarios:
       **
       **   (a) A call to fstat() failed.
       **   (b) A malloc failed.
       **
       ** Scenario (b) may only occur if the process is holding no other
       ** file descriptors open on the same file. If there were other file
       ** descriptors on this file, then no malloc would be required by
       ** findInodeInfo(). If this is the case, it is quite safe to close
       ** handle h - as it is guaranteed that no posix locks will be released
       ** by doing so.
       **
       ** If scenario (a) caused the error then things are not so safe. The
       ** implicit assumption here is that if fstat() fails, things are in
       ** such bad shape that dropping a lock or two doesn't matter much.
       */
       robust_close(pNew, h, __LINE__);
       h = -1;
     }
     unixLeaveMutex();
   }
 
 #if SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__)
   else if( pLockingStyle == &afpIoMethods ){
     /* AFP locking uses the file path so it needs to be included in
     ** the afpLockingContext.
     */
     afpLockingContext *pCtx;
     pNew->lockingContext = pCtx = sqlite3_malloc( sizeof(*pCtx) );
     if( pCtx==0 ){
       rc = SQLITE_NOMEM;
     }else{
       /* NB: zFilename exists and remains valid until the file is closed
       ** according to requirement F11141.  So we do not need to make a
       ** copy of the filename. */
       pCtx->dbPath = zFilename;
       pCtx->reserved = 0;
       srandomdev();
       unixEnterMutex();
       rc = findInodeInfo(pNew, &pNew->pInode);
       if( rc!=SQLITE_OK ){
         sqlite3_free(pNew->lockingContext);
         robust_close(pNew, h, __LINE__);
         h = -1;
       }
       unixLeaveMutex();        
     }
   }
 #endif
 
   else if( pLockingStyle == &dotlockIoMethods ){
     /* Dotfile locking uses the file path so it needs to be included in
     ** the dotlockLockingContext 
     */
     char *zLockFile;
     int nFilename;
     assert( zFilename!=0 );
     nFilename = (int)strlen(zFilename) + 6;
     zLockFile = (char *)sqlite3_malloc(nFilename);
     if( zLockFile==0 ){
       rc = SQLITE_NOMEM;
     }else{
       sqlite3_snprintf(nFilename, zLockFile, "%s" DOTLOCK_SUFFIX, zFilename);
     }
     pNew->lockingContext = zLockFile;
   }
 
 #if OS_VXWORKS
   else if( pLockingStyle == &semIoMethods ){
     /* Named semaphore locking uses the file path so it needs to be
     ** included in the semLockingContext
     */
     unixEnterMutex();
     rc = findInodeInfo(pNew, &pNew->pInode);
     if( (rc==SQLITE_OK) && (pNew->pInode->pSem==NULL) ){
       char *zSemName = pNew->pInode->aSemName;
       int n;
       sqlite3_snprintf(MAX_PATHNAME, zSemName, "/%s.sem",
                        pNew->pId->zCanonicalName);
       for( n=1; zSemName[n]; n++ )
         if( zSemName[n]=='/' ) zSemName[n] = '_';
       pNew->pInode->pSem = sem_open(zSemName, O_CREAT, 0666, 1);
       if( pNew->pInode->pSem == SEM_FAILED ){
         rc = SQLITE_NOMEM;
         pNew->pInode->aSemName[0] = '\0';
       }
     }
     unixLeaveMutex();
   }
 #endif
   
   storeLastErrno(pNew, 0);
 #if OS_VXWORKS
   if( rc!=SQLITE_OK ){
     if( h>=0 ) robust_close(pNew, h, __LINE__);
     h = -1;
     osUnlink(zFilename);
     pNew->ctrlFlags |= UNIXFILE_DELETE;
   }
 #endif
   if( rc!=SQLITE_OK ){
     if( h>=0 ) robust_close(pNew, h, __LINE__);
   }else{
     pNew->pMethod = pLockingStyle;
     OpenCounter(+1);
     verifyDbFile(pNew);
   }
   return rc;
 }

int sqlite2BtreeKeyCompare	(	BtCursor *	,
		const void *	,
		int	,
		int	,
		int *
	)

SQLITE_API void *SQLITE_STDCALL sqlite3_aggregate_context	(	sqlite3_context *	p,
		int	nBytes
	)

Definition at line 69712 of file sqlite3.c.

References sqlite3_value::flags, sqlite3_context::pMem, and sqlite3_value::z.

                                                                                         {
   assert( p && p->pFunc && p->pFunc->xStep );
   assert( sqlite3_mutex_held(p->pOut->db->mutex) );
   testcase( nByte<0 );
   if( (p->pMem->flags & MEM_Agg)==0 ){
     return createAggContext(p, nByte);
   }else{
     return (void*)p->pMem->z;
   }
 }

SQLITE_API int SQLITE_STDCALL sqlite3_aggregate_count ( sqlite3_context * p )

Definition at line 69803 of file sqlite3.c.

References sqlite3_value::n, and sqlite3_context::pMem.

                                                                          {
   assert( p && p->pMem && p->pFunc && p->pFunc->xStep );
   return p->pMem->n;
 }

SQLITE_API int SQLITE_STDCALL sqlite3_auto_extension ( void(*)(void) xEntryPoint )

Definition at line 103011 of file sqlite3.c.

References sqlite3_initialize(), sqlite3_mutex_enter(), sqlite3_mutex_leave(), and sqlite3MutexAlloc().

                                                                          {
   int rc = SQLITE_OK;
 #ifndef SQLITE_OMIT_AUTOINIT
   rc = sqlite3_initialize();
   if( rc ){
     return rc;
   }else
 #endif
   {
     int i;
 #if SQLITE_THREADSAFE
     sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER);
 #endif
     wsdAutoextInit;
     sqlite3_mutex_enter(mutex);
     for(i=0; i<wsdAutoext.nExt; i++){
       if( wsdAutoext.aExt[i]==xInit ) break;
     }
     if( i==wsdAutoext.nExt ){
       int nByte = (wsdAutoext.nExt+1)*sizeof(wsdAutoext.aExt[0]);
       void (**aNew)(void);
       aNew = sqlite3_realloc(wsdAutoext.aExt, nByte);
       if( aNew==0 ){
         rc = SQLITE_NOMEM;
       }else{
         wsdAutoext.aExt = aNew;
         wsdAutoext.aExt[wsdAutoext.nExt] = xInit;
         wsdAutoext.nExt++;
       }
     }
     sqlite3_mutex_leave(mutex);
     assert( (rc&0xff)==rc );
     return rc;
   }
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_backup_finish ( sqlite3_backup * p )

Definition at line 62930 of file sqlite3.c.

References sqlite3_backup::isAttached, sqlite3::mutex, Btree::nBackup, sqlite3_backup::pDest, sqlite3_backup::pDestDb, sqlite3_backup::pNext, sqlite3_backup::pSrc, sqlite3_backup::pSrcDb, sqlite3_backup::rc, sqlite3_free(), sqlite3_mutex_enter(), sqlite3BtreeEnter(), sqlite3BtreeLeave(), sqlite3BtreePager(), sqlite3BtreeRollback(), sqlite3Error(), sqlite3LeaveMutexAndCloseZombie(), and sqlite3PagerBackupPtr().

Referenced by sqlite3BtreeCopyFile().

                                                                       {
   sqlite3_backup **pp;                 /* Ptr to head of pagers backup list */
   sqlite3 *pSrcDb;                     /* Source database connection */
   int rc;                              /* Value to return */
 
   /* Enter the mutexes */
   if( p==0 ) return SQLITE_OK;
   pSrcDb = p->pSrcDb;
   sqlite3_mutex_enter(pSrcDb->mutex);
   sqlite3BtreeEnter(p->pSrc);
   if( p->pDestDb ){
     sqlite3_mutex_enter(p->pDestDb->mutex);
   }
 
   /* Detach this backup from the source pager. */
   if( p->pDestDb ){
     p->pSrc->nBackup--;
   }
   if( p->isAttached ){
     pp = sqlite3PagerBackupPtr(sqlite3BtreePager(p->pSrc));
     while( *pp!=p ){
       pp = &(*pp)->pNext;
     }
     *pp = p->pNext;
   }
 
   /* If a transaction is still open on the Btree, roll it back. */
   sqlite3BtreeRollback(p->pDest, SQLITE_OK, 0);
 
   /* Set the error code of the destination database handle. */
   rc = (p->rc==SQLITE_DONE) ? SQLITE_OK : p->rc;
   if( p->pDestDb ){
     sqlite3Error(p->pDestDb, rc);
 
     /* Exit the mutexes and free the backup context structure. */
     sqlite3LeaveMutexAndCloseZombie(p->pDestDb);
   }
   sqlite3BtreeLeave(p->pSrc);
   if( p->pDestDb ){
     /* EVIDENCE-OF: R-64852-21591 The sqlite3_backup object is created by a
     ** call to sqlite3_backup_init() and is destroyed by a call to
     ** sqlite3_backup_finish(). */
     sqlite3_free(p);
   }
   sqlite3LeaveMutexAndCloseZombie(pSrcDb);
   return rc;
 }

Here is the call graph for this function:

SQLITE_API sqlite3_backup *SQLITE_STDCALL sqlite3_backup_init	(	sqlite3 *	pDest,
		const char *	zDestName,
		sqlite3 *	pSource,
		const char *	zSourceName
	)

Definition at line 62477 of file sqlite3.c.

References sqlite3_backup::iNext, sqlite3_backup::isAttached, sqlite3::mutex, Btree::nBackup, sqlite3_backup::pDest, sqlite3_backup::pDestDb, sqlite3_backup::pSrc, sqlite3_backup::pSrcDb, sqlite3_free(), sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3Error(), sqlite3ErrorWithMsg(), and sqlite3MallocZero().

  {
   sqlite3_backup *p;                    /* Value to return */
 
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(pSrcDb)||!sqlite3SafetyCheckOk(pDestDb) ){
     (void)SQLITE_MISUSE_BKPT;
     return 0;
   }
 #endif
 
   /* Lock the source database handle. The destination database
   ** handle is not locked in this routine, but it is locked in
   ** sqlite3_backup_step(). The user is required to ensure that no
   ** other thread accesses the destination handle for the duration
   ** of the backup operation.  Any attempt to use the destination
   ** database connection while a backup is in progress may cause
   ** a malfunction or a deadlock.
   */
   sqlite3_mutex_enter(pSrcDb->mutex);
   sqlite3_mutex_enter(pDestDb->mutex);
 
   if( pSrcDb==pDestDb ){
     sqlite3ErrorWithMsg(
         pDestDb, SQLITE_ERROR, "source and destination must be distinct"
     );
     p = 0;
   }else {
     /* Allocate space for a new sqlite3_backup object...
     ** EVIDENCE-OF: R-64852-21591 The sqlite3_backup object is created by a
     ** call to sqlite3_backup_init() and is destroyed by a call to
     ** sqlite3_backup_finish(). */
     p = (sqlite3_backup *)sqlite3MallocZero(sizeof(sqlite3_backup));
     if( !p ){
       sqlite3Error(pDestDb, SQLITE_NOMEM);
     }
   }
 
   /* If the allocation succeeded, populate the new object. */
   if( p ){
     p->pSrc = findBtree(pDestDb, pSrcDb, zSrcDb);
     p->pDest = findBtree(pDestDb, pDestDb, zDestDb);
     p->pDestDb = pDestDb;
     p->pSrcDb = pSrcDb;
     p->iNext = 1;
     p->isAttached = 0;
 
     if( 0==p->pSrc || 0==p->pDest 
      || setDestPgsz(p)==SQLITE_NOMEM 
      || checkReadTransaction(pDestDb, p->pDest)!=SQLITE_OK 
      ){
       /* One (or both) of the named databases did not exist or an OOM
       ** error was hit. Or there is a transaction open on the destination
       ** database. The error has already been written into the pDestDb 
       ** handle. All that is left to do here is free the sqlite3_backup 
       ** structure.  */
       sqlite3_free(p);
       p = 0;
     }
   }
   if( p ){
     p->pSrc->nBackup++;
   }
 
   sqlite3_mutex_leave(pDestDb->mutex);
   sqlite3_mutex_leave(pSrcDb->mutex);
   return p;
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_backup_pagecount ( sqlite3_backup * p )

Definition at line 62996 of file sqlite3.c.

References sqlite3_backup::nPagecount.

                                                                          {
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( p==0 ){
     (void)SQLITE_MISUSE_BKPT;
     return 0;
   }
 #endif
   return p->nPagecount;
 }

SQLITE_API int SQLITE_STDCALL sqlite3_backup_remaining ( sqlite3_backup * p )

Definition at line 62982 of file sqlite3.c.

References sqlite3_backup::nRemaining.

                                                                          {
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( p==0 ){
     (void)SQLITE_MISUSE_BKPT;
     return 0;
   }
 #endif
   return p->nRemaining;
 }

SQLITE_API int SQLITE_STDCALL sqlite3_backup_step	(	sqlite3_backup *	p,
		int	nPage
	)

Definition at line 62685 of file sqlite3.c.

References sqlite3_backup::bDestLocked, sqlite3_backup::iDestSchema, sqlite3_backup::iNext, BtShared::inTransaction, sqlite3_backup::isAttached, sqlite3::mutex, sqlite3_backup::nPagecount, sqlite3_backup::nRemaining, Btree::pBt, sqlite3_backup::pDest, sqlite3_backup::pDestDb, sqlite3_backup::pSrc, sqlite3_backup::pSrcDb, sqlite3_backup::rc, sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3BtreeBeginTrans(), sqlite3BtreeCommitPhaseOne(), sqlite3BtreeCommitPhaseTwo(), sqlite3BtreeEnter(), sqlite3BtreeGetMeta(), sqlite3BtreeGetPageSize(), sqlite3BtreeIsInReadTrans(), sqlite3BtreeLastPage(), sqlite3BtreeLeave(), sqlite3BtreeNewDb(), sqlite3BtreePager(), sqlite3BtreeSetVersion(), sqlite3BtreeUpdateMeta(), sqlite3PagerAcquire(), sqlite3PagerCommitPhaseOne(), sqlite3PagerFile(), sqlite3PagerGetJournalMode(), sqlite3PagerPagecount(), sqlite3PagerSync(), sqlite3PagerTruncateImage(), sqlite3PagerUnref(), sqlite3PagerWrite(), and sqlite3ResetAllSchemasOfConnection().

Referenced by sqlite3BtreeCopyFile().

                                                                                {
   int rc;
   int destMode;       /* Destination journal mode */
   int pgszSrc = 0;    /* Source page size */
   int pgszDest = 0;   /* Destination page size */
 
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( p==0 ) return SQLITE_MISUSE_BKPT;
 #endif
   sqlite3_mutex_enter(p->pSrcDb->mutex);
   sqlite3BtreeEnter(p->pSrc);
   if( p->pDestDb ){
     sqlite3_mutex_enter(p->pDestDb->mutex);
   }
 
   rc = p->rc;
   if( !isFatalError(rc) ){
     Pager * const pSrcPager = sqlite3BtreePager(p->pSrc);     /* Source pager */
     Pager * const pDestPager = sqlite3BtreePager(p->pDest);   /* Dest pager */
     int ii;                            /* Iterator variable */
     int nSrcPage = -1;                 /* Size of source db in pages */
     int bCloseTrans = 0;               /* True if src db requires unlocking */
 
     /* If the source pager is currently in a write-transaction, return
     ** SQLITE_BUSY immediately.
     */
     if( p->pDestDb && p->pSrc->pBt->inTransaction==TRANS_WRITE ){
       rc = SQLITE_BUSY;
     }else{
       rc = SQLITE_OK;
     }
 
     /* Lock the destination database, if it is not locked already. */
     if( SQLITE_OK==rc && p->bDestLocked==0
      && SQLITE_OK==(rc = sqlite3BtreeBeginTrans(p->pDest, 2)) 
     ){
       p->bDestLocked = 1;
       sqlite3BtreeGetMeta(p->pDest, BTREE_SCHEMA_VERSION, &p->iDestSchema);
     }
 
     /* If there is no open read-transaction on the source database, open
     ** one now. If a transaction is opened here, then it will be closed
     ** before this function exits.
     */
     if( rc==SQLITE_OK && 0==sqlite3BtreeIsInReadTrans(p->pSrc) ){
       rc = sqlite3BtreeBeginTrans(p->pSrc, 0);
       bCloseTrans = 1;
     }
 
     /* Do not allow backup if the destination database is in WAL mode
     ** and the page sizes are different between source and destination */
     pgszSrc = sqlite3BtreeGetPageSize(p->pSrc);
     pgszDest = sqlite3BtreeGetPageSize(p->pDest);
     destMode = sqlite3PagerGetJournalMode(sqlite3BtreePager(p->pDest));
     if( SQLITE_OK==rc && destMode==PAGER_JOURNALMODE_WAL && pgszSrc!=pgszDest ){
       rc = SQLITE_READONLY;
     }
   
     /* Now that there is a read-lock on the source database, query the
     ** source pager for the number of pages in the database.
     */
     nSrcPage = (int)sqlite3BtreeLastPage(p->pSrc);
     assert( nSrcPage>=0 );
     for(ii=0; (nPage<0 || ii<nPage) && p->iNext<=(Pgno)nSrcPage && !rc; ii++){
       const Pgno iSrcPg = p->iNext;                 /* Source page number */
       if( iSrcPg!=PENDING_BYTE_PAGE(p->pSrc->pBt) ){
         DbPage *pSrcPg;                             /* Source page object */
         rc = sqlite3PagerAcquire(pSrcPager, iSrcPg, &pSrcPg,
                                  PAGER_GET_READONLY);
         if( rc==SQLITE_OK ){
           rc = backupOnePage(p, iSrcPg, sqlite3PagerGetData(pSrcPg), 0);
           sqlite3PagerUnref(pSrcPg);
         }
       }
       p->iNext++;
     }
     if( rc==SQLITE_OK ){
       p->nPagecount = nSrcPage;
       p->nRemaining = nSrcPage+1-p->iNext;
       if( p->iNext>(Pgno)nSrcPage ){
         rc = SQLITE_DONE;
       }else if( !p->isAttached ){
         attachBackupObject(p);
       }
     }
   
     /* Update the schema version field in the destination database. This
     ** is to make sure that the schema-version really does change in
     ** the case where the source and destination databases have the
     ** same schema version.
     */
     if( rc==SQLITE_DONE ){
       if( nSrcPage==0 ){
         rc = sqlite3BtreeNewDb(p->pDest);
         nSrcPage = 1;
       }
       if( rc==SQLITE_OK || rc==SQLITE_DONE ){
         rc = sqlite3BtreeUpdateMeta(p->pDest,1,p->iDestSchema+1);
       }
       if( rc==SQLITE_OK ){
         if( p->pDestDb ){
           sqlite3ResetAllSchemasOfConnection(p->pDestDb);
         }
         if( destMode==PAGER_JOURNALMODE_WAL ){
           rc = sqlite3BtreeSetVersion(p->pDest, 2);
         }
       }
       if( rc==SQLITE_OK ){
         int nDestTruncate;
         /* Set nDestTruncate to the final number of pages in the destination
         ** database. The complication here is that the destination page
         ** size may be different to the source page size. 
         **
         ** If the source page size is smaller than the destination page size, 
         ** round up. In this case the call to sqlite3OsTruncate() below will
         ** fix the size of the file. However it is important to call
         ** sqlite3PagerTruncateImage() here so that any pages in the 
         ** destination file that lie beyond the nDestTruncate page mark are
         ** journalled by PagerCommitPhaseOne() before they are destroyed
         ** by the file truncation.
         */
         assert( pgszSrc==sqlite3BtreeGetPageSize(p->pSrc) );
         assert( pgszDest==sqlite3BtreeGetPageSize(p->pDest) );
         if( pgszSrc<pgszDest ){
           int ratio = pgszDest/pgszSrc;
           nDestTruncate = (nSrcPage+ratio-1)/ratio;
           if( nDestTruncate==(int)PENDING_BYTE_PAGE(p->pDest->pBt) ){
             nDestTruncate--;
           }
         }else{
           nDestTruncate = nSrcPage * (pgszSrc/pgszDest);
         }
         assert( nDestTruncate>0 );
 
         if( pgszSrc<pgszDest ){
           /* If the source page-size is smaller than the destination page-size,
           ** two extra things may need to happen:
           **
           **   * The destination may need to be truncated, and
           **
           **   * Data stored on the pages immediately following the 
           **     pending-byte page in the source database may need to be
           **     copied into the destination database.
           */
           const i64 iSize = (i64)pgszSrc * (i64)nSrcPage;
           sqlite3_file * const pFile = sqlite3PagerFile(pDestPager);
           Pgno iPg;
           int nDstPage;
           i64 iOff;
           i64 iEnd;
 
           assert( pFile );
           assert( nDestTruncate==0 
               || (i64)nDestTruncate*(i64)pgszDest >= iSize || (
                 nDestTruncate==(int)(PENDING_BYTE_PAGE(p->pDest->pBt)-1)
              && iSize>=PENDING_BYTE && iSize<=PENDING_BYTE+pgszDest
           ));
 
           /* This block ensures that all data required to recreate the original
           ** database has been stored in the journal for pDestPager and the
           ** journal synced to disk. So at this point we may safely modify
           ** the database file in any way, knowing that if a power failure
           ** occurs, the original database will be reconstructed from the 
           ** journal file.  */
           sqlite3PagerPagecount(pDestPager, &nDstPage);
           for(iPg=nDestTruncate; rc==SQLITE_OK && iPg<=(Pgno)nDstPage; iPg++){
             if( iPg!=PENDING_BYTE_PAGE(p->pDest->pBt) ){
               DbPage *pPg;
               rc = sqlite3PagerGet(pDestPager, iPg, &pPg);
               if( rc==SQLITE_OK ){
                 rc = sqlite3PagerWrite(pPg);
                 sqlite3PagerUnref(pPg);
               }
             }
           }
           if( rc==SQLITE_OK ){
             rc = sqlite3PagerCommitPhaseOne(pDestPager, 0, 1);
           }
 
           /* Write the extra pages and truncate the database file as required */
           iEnd = MIN(PENDING_BYTE + pgszDest, iSize);
           for(
             iOff=PENDING_BYTE+pgszSrc; 
             rc==SQLITE_OK && iOff<iEnd; 
             iOff+=pgszSrc
           ){
             PgHdr *pSrcPg = 0;
             const Pgno iSrcPg = (Pgno)((iOff/pgszSrc)+1);
             rc = sqlite3PagerGet(pSrcPager, iSrcPg, &pSrcPg);
             if( rc==SQLITE_OK ){
               u8 *zData = sqlite3PagerGetData(pSrcPg);
               rc = sqlite3OsWrite(pFile, zData, pgszSrc, iOff);
             }
             sqlite3PagerUnref(pSrcPg);
           }
           if( rc==SQLITE_OK ){
             rc = backupTruncateFile(pFile, iSize);
           }
 
           /* Sync the database file to disk. */
           if( rc==SQLITE_OK ){
             rc = sqlite3PagerSync(pDestPager, 0);
           }
         }else{
           sqlite3PagerTruncateImage(pDestPager, nDestTruncate);
           rc = sqlite3PagerCommitPhaseOne(pDestPager, 0, 0);
         }
     
         /* Finish committing the transaction to the destination database. */
         if( SQLITE_OK==rc
          && SQLITE_OK==(rc = sqlite3BtreeCommitPhaseTwo(p->pDest, 0))
         ){
           rc = SQLITE_DONE;
         }
       }
     }
   
     /* If bCloseTrans is true, then this function opened a read transaction
     ** on the source database. Close the read transaction here. There is
     ** no need to check the return values of the btree methods here, as
     ** "committing" a read-only transaction cannot fail.
     */
     if( bCloseTrans ){
       TESTONLY( int rc2 );
       TESTONLY( rc2  = ) sqlite3BtreeCommitPhaseOne(p->pSrc, 0);
       TESTONLY( rc2 |= ) sqlite3BtreeCommitPhaseTwo(p->pSrc, 0);
       assert( rc2==SQLITE_OK );
     }
   
     if( rc==SQLITE_IOERR_NOMEM ){
       rc = SQLITE_NOMEM;
     }
     p->rc = rc;
   }
   if( p->pDestDb ){
     sqlite3_mutex_leave(p->pDestDb->mutex);
   }
   sqlite3BtreeLeave(p->pSrc);
   sqlite3_mutex_leave(p->pSrcDb->mutex);
   return rc;
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_bind_blob	(	sqlite3_stmt *	pStmt,
		int	i,
		const void *	zData,
		int	n,
		void()(void )	xDel
	)

Definition at line 70224 of file sqlite3.c.

Referenced by sqlite3_bind_value().

  {
   return bindText(pStmt, i, zData, nData, xDel, 0);
 }

SQLITE_API int SQLITE_STDCALL sqlite3_bind_blob64	(	sqlite3_stmt *	pStmt,
		int	i,
		const void *	zData,
		sqlite3_uint64	nData,
		void()(void )	xDel
	)

Definition at line 70233 of file sqlite3.c.

  {
   assert( xDel!=SQLITE_DYNAMIC );
   if( nData>0x7fffffff ){
     return invokeValueDestructor(zData, xDel, 0);
   }else{
     return bindText(pStmt, i, zData, (int)nData, xDel, 0);
   }
 }

SQLITE_API int SQLITE_STDCALL sqlite3_bind_double	(	sqlite3_stmt *	pStmt,
		int	i,
		double	rValue
	)

Definition at line 70247 of file sqlite3.c.

References Vdbe::aVar, Vdbe::db, sqlite3::mutex, sqlite3_mutex_leave(), and sqlite3VdbeMemSetDouble().

Referenced by sqlite3_bind_value().

                                                                                             {
   int rc;
   Vdbe *p = (Vdbe *)pStmt;
   rc = vdbeUnbind(p, i);
   if( rc==SQLITE_OK ){
     sqlite3VdbeMemSetDouble(&p->aVar[i-1], rValue);
     sqlite3_mutex_leave(p->db->mutex);
   }
   return rc;
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_bind_int	(	sqlite3_stmt *	p,
		int	i,
		int	iValue
	)

Definition at line 70257 of file sqlite3.c.

References sqlite3_bind_int64().

                                                                                   {
   return sqlite3_bind_int64(p, i, (i64)iValue);
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_bind_int64	(	sqlite3_stmt *	pStmt,
		int	i,
		sqlite3_int64	iValue
	)

Definition at line 70260 of file sqlite3.c.

References Vdbe::aVar, Vdbe::db, sqlite3::mutex, sqlite3_mutex_leave(), and sqlite3VdbeMemSetInt64().

Referenced by sqlite3_bind_int(), sqlite3_bind_value(), and sqlite3_blob_open().

                                                                                                  {
   int rc;
   Vdbe *p = (Vdbe *)pStmt;
   rc = vdbeUnbind(p, i);
   if( rc==SQLITE_OK ){
     sqlite3VdbeMemSetInt64(&p->aVar[i-1], iValue);
     sqlite3_mutex_leave(p->db->mutex);
   }
   return rc;
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_bind_null	(	sqlite3_stmt *	pStmt,
		int	i
	)

Definition at line 70270 of file sqlite3.c.

References Vdbe::db, sqlite3::mutex, and sqlite3_mutex_leave().

Referenced by sqlite3_bind_value().

                                                                            {
   int rc;
   Vdbe *p = (Vdbe*)pStmt;
   rc = vdbeUnbind(p, i);
   if( rc==SQLITE_OK ){
     sqlite3_mutex_leave(p->db->mutex);
   }
   return rc;
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_bind_parameter_count ( sqlite3_stmt * pStmt )

Definition at line 70361 of file sqlite3.c.

References Vdbe::nVar.

                                                                                {
   Vdbe *p = (Vdbe*)pStmt;
   return p ? p->nVar : 0;
 }

SQLITE_API int SQLITE_STDCALL sqlite3_bind_parameter_index	(	sqlite3_stmt *	pStmt,
		const char *	zName
	)

Definition at line 70400 of file sqlite3.c.

References sqlite3Strlen30(), and sqlite3VdbeParameterIndex().

                                                                                                   {
   return sqlite3VdbeParameterIndex((Vdbe*)pStmt, zName, sqlite3Strlen30(zName));
 }

Here is the call graph for this function:

SQLITE_API const char *SQLITE_STDCALL sqlite3_bind_parameter_name	(	sqlite3_stmt *	pStmt,
		int	i
	)

Definition at line 70372 of file sqlite3.c.

References Vdbe::azVar, and Vdbe::nzVar.

                                                                                              {
   Vdbe *p = (Vdbe*)pStmt;
   if( p==0 || i<1 || i>p->nzVar ){
     return 0;
   }
   return p->azVar[i-1];
 }

SQLITE_API int SQLITE_STDCALL sqlite3_bind_text	(	sqlite3_stmt *	pStmt,
		int	i,
		const char *	zData,
		int	nData,
		void()(void )	xDel
	)

Definition at line 70279 of file sqlite3.c.

  {
   return bindText(pStmt, i, zData, nData, xDel, SQLITE_UTF8);
 }

SQLITE_API int SQLITE_STDCALL sqlite3_bind_text16	(	sqlite3_stmt *	pStmt,
		int	i,
		const void *	zData,
		int	nData,
		void()(void )	xDel
	)

Definition at line 70305 of file sqlite3.c.

  {
   return bindText(pStmt, i, zData, nData, xDel, SQLITE_UTF16NATIVE);
 }

SQLITE_API int SQLITE_STDCALL sqlite3_bind_text64	(	sqlite3_stmt *	pStmt,
		int	i,
		const char *	zData,
		sqlite3_uint64	nData,
		void()(void )	xDel,
		unsigned char	encoding
	)

Definition at line 70288 of file sqlite3.c.

  {
   assert( xDel!=SQLITE_DYNAMIC );
   if( nData>0x7fffffff ){
     return invokeValueDestructor(zData, xDel, 0);
   }else{
     if( enc==SQLITE_UTF16 ) enc = SQLITE_UTF16NATIVE;
     return bindText(pStmt, i, zData, (int)nData, xDel, enc);
   }
 }

SQLITE_API int SQLITE_STDCALL sqlite3_bind_value	(	sqlite3_stmt *	pStmt,
		int	i,
		const sqlite3_value *	pValue
	)

Definition at line 70315 of file sqlite3.c.

References sqlite3_value::enc, sqlite3_value::flags, sqlite3_value::MemValue::i, sqlite3_value::n, sqlite3_value::MemValue::nZero, sqlite3_value::MemValue::r, sqlite3_bind_blob(), sqlite3_bind_double(), sqlite3_bind_int64(), sqlite3_bind_null(), sqlite3_bind_zeroblob(), sqlite3_value_type(), and sqlite3_value::z.

                                                                                                          {
   int rc;
   switch( sqlite3_value_type((sqlite3_value*)pValue) ){
     case SQLITE_INTEGER: {
       rc = sqlite3_bind_int64(pStmt, i, pValue->u.i);
       break;
     }
     case SQLITE_FLOAT: {
       rc = sqlite3_bind_double(pStmt, i, pValue->u.r);
       break;
     }
     case SQLITE_BLOB: {
       if( pValue->flags & MEM_Zero ){
         rc = sqlite3_bind_zeroblob(pStmt, i, pValue->u.nZero);
       }else{
         rc = sqlite3_bind_blob(pStmt, i, pValue->z, pValue->n,SQLITE_TRANSIENT);
       }
       break;
     }
     case SQLITE_TEXT: {
       rc = bindText(pStmt,i,  pValue->z, pValue->n, SQLITE_TRANSIENT,
                               pValue->enc);
       break;
     }
     default: {
       rc = sqlite3_bind_null(pStmt, i);
       break;
     }
   }
   return rc;
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_bind_zeroblob	(	sqlite3_stmt *	pStmt,
		int	i,
		int	n
	)

Definition at line 70346 of file sqlite3.c.

References Vdbe::aVar, Vdbe::db, sqlite3::mutex, sqlite3_mutex_leave(), and sqlite3VdbeMemSetZeroBlob().

Referenced by sqlite3_bind_value().

                                                                                       {
   int rc;
   Vdbe *p = (Vdbe *)pStmt;
   rc = vdbeUnbind(p, i);
   if( rc==SQLITE_OK ){
     sqlite3VdbeMemSetZeroBlob(&p->aVar[i-1], n);
     sqlite3_mutex_leave(p->db->mutex);
   }
   return rc;
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_blob_bytes ( sqlite3_blob * pBlob )

Definition at line 77883 of file sqlite3.c.

References Incrblob::nByte, and Incrblob::pStmt.

                                                                      {
   Incrblob *p = (Incrblob *)pBlob;
   return (p && p->pStmt) ? p->nByte : 0;
 }

SQLITE_API int SQLITE_STDCALL sqlite3_blob_close ( sqlite3_blob * pBlob )

Definition at line 77797 of file sqlite3.c.

References Incrblob::db, sqlite3::mutex, Incrblob::pStmt, sqlite3_finalize(), sqlite3_mutex_enter(), sqlite3_mutex_leave(), and sqlite3DbFree().

                                                                      {
   Incrblob *p = (Incrblob *)pBlob;
   int rc;
   sqlite3 *db;
 
   if( p ){
     db = p->db;
     sqlite3_mutex_enter(db->mutex);
     rc = sqlite3_finalize(p->pStmt);
     sqlite3DbFree(db, p);
     sqlite3_mutex_leave(db->mutex);
   }else{
     rc = SQLITE_OK;
   }
   return rc;
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_blob_open	(	sqlite3 *	db,
		const char *	zDb,
		const char *	zTable,
		const char *	zColumn,
		sqlite3_int64	iRow,
		int	flags,
		sqlite3_blob **	ppBlob
	)

Definition at line 77560 of file sqlite3.c.

References Table::aCol, Index::aiColumn, Parse::db, Incrblob::db, sqlite3::flags, Incrblob::flags, Incrblob::iCol, FKey::sColMap::iFrom, Schema::iGeneration, sqlite3::mallocFailed, sqlite3::mutex, Table::nCol, FKey::nCol, Index::nKeyCol, Parse::nMem, Parse::nTab, Parse::nVar, Table::pFKey, Table::pIndex, Index::pNext, FKey::pNextFrom, Table::pSchema, Table::pSelect, Incrblob::pStmt, Schema::schema_cookie, sqlite3_bind_int64(), sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3_stricmp(), sqlite3ApiExit(), sqlite3BtreeEnterAll(), sqlite3BtreeLeaveAll(), sqlite3DbFree(), sqlite3DbMallocZero(), sqlite3ErrorMsg(), sqlite3ErrorWithMsg(), sqlite3LocateTable(), sqlite3MPrintf(), sqlite3ParserReset(), sqlite3SchemaToIndex(), sqlite3VdbeAddOp4Int(), sqlite3VdbeAddOpList(), sqlite3VdbeChangeP1(), sqlite3VdbeChangeP2(), sqlite3VdbeChangeP3(), sqlite3VdbeChangeP4(), sqlite3VdbeChangeP5(), sqlite3VdbeChangeToNoop(), sqlite3VdbeCreate(), sqlite3VdbeFinalize(), sqlite3VdbeMakeReady(), sqlite3VdbeUsesBtree(), Table::tnum, Parse::zErrMsg, Column::zName, and Table::zName.

  {
   int nAttempt = 0;
   int iCol;               /* Index of zColumn in row-record */
 
   /* This VDBE program seeks a btree cursor to the identified 
   ** db/table/row entry. The reason for using a vdbe program instead
   ** of writing code to use the b-tree layer directly is that the
   ** vdbe program will take advantage of the various transaction,
   ** locking and error handling infrastructure built into the vdbe.
   **
   ** After seeking the cursor, the vdbe executes an OP_ResultRow.
   ** Code external to the Vdbe then "borrows" the b-tree cursor and
   ** uses it to implement the blob_read(), blob_write() and 
   ** blob_bytes() functions.
   **
   ** The sqlite3_blob_close() function finalizes the vdbe program,
   ** which closes the b-tree cursor and (possibly) commits the 
   ** transaction.
   */
   static const int iLn = VDBE_OFFSET_LINENO(4);
   static const VdbeOpList openBlob[] = {
     /* {OP_Transaction, 0, 0, 0},  // 0: Inserted separately */
     {OP_TableLock, 0, 0, 0},       /* 1: Acquire a read or write lock */
     /* One of the following two instructions is replaced by an OP_Noop. */
     {OP_OpenRead, 0, 0, 0},        /* 2: Open cursor 0 for reading */
     {OP_OpenWrite, 0, 0, 0},       /* 3: Open cursor 0 for read/write */
     {OP_Variable, 1, 1, 1},        /* 4: Push the rowid to the stack */
     {OP_NotExists, 0, 10, 1},      /* 5: Seek the cursor */
     {OP_Column, 0, 0, 1},          /* 6  */
     {OP_ResultRow, 1, 0, 0},       /* 7  */
     {OP_Goto, 0, 4, 0},            /* 8  */
     {OP_Close, 0, 0, 0},           /* 9  */
     {OP_Halt, 0, 0, 0},            /* 10 */
   };
 
   int rc = SQLITE_OK;
   char *zErr = 0;
   Table *pTab;
   Parse *pParse = 0;
   Incrblob *pBlob = 0;
 
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( ppBlob==0 ){
     return SQLITE_MISUSE_BKPT;
   }
 #endif
   *ppBlob = 0;
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(db) || zTable==0 ){
     return SQLITE_MISUSE_BKPT;
   }
 #endif
   flags = !!flags;                /* flags = (flags ? 1 : 0); */
 
   sqlite3_mutex_enter(db->mutex);
 
   pBlob = (Incrblob *)sqlite3DbMallocZero(db, sizeof(Incrblob));
   if( !pBlob ) goto blob_open_out;
   pParse = sqlite3StackAllocRaw(db, sizeof(*pParse));
   if( !pParse ) goto blob_open_out;
 
   do {
     memset(pParse, 0, sizeof(Parse));
     pParse->db = db;
     sqlite3DbFree(db, zErr);
     zErr = 0;
 
     sqlite3BtreeEnterAll(db);
     pTab = sqlite3LocateTable(pParse, 0, zTable, zDb);
     if( pTab && IsVirtual(pTab) ){
       pTab = 0;
       sqlite3ErrorMsg(pParse, "cannot open virtual table: %s", zTable);
     }
     if( pTab && !HasRowid(pTab) ){
       pTab = 0;
       sqlite3ErrorMsg(pParse, "cannot open table without rowid: %s", zTable);
     }
 #ifndef SQLITE_OMIT_VIEW
     if( pTab && pTab->pSelect ){
       pTab = 0;
       sqlite3ErrorMsg(pParse, "cannot open view: %s", zTable);
     }
 #endif
     if( !pTab ){
       if( pParse->zErrMsg ){
         sqlite3DbFree(db, zErr);
         zErr = pParse->zErrMsg;
         pParse->zErrMsg = 0;
       }
       rc = SQLITE_ERROR;
       sqlite3BtreeLeaveAll(db);
       goto blob_open_out;
     }
 
     /* Now search pTab for the exact column. */
     for(iCol=0; iCol<pTab->nCol; iCol++) {
       if( sqlite3StrICmp(pTab->aCol[iCol].zName, zColumn)==0 ){
         break;
       }
     }
     if( iCol==pTab->nCol ){
       sqlite3DbFree(db, zErr);
       zErr = sqlite3MPrintf(db, "no such column: \"%s\"", zColumn);
       rc = SQLITE_ERROR;
       sqlite3BtreeLeaveAll(db);
       goto blob_open_out;
     }
 
     /* If the value is being opened for writing, check that the
     ** column is not indexed, and that it is not part of a foreign key. 
     ** It is against the rules to open a column to which either of these
     ** descriptions applies for writing.  */
     if( flags ){
       const char *zFault = 0;
       Index *pIdx;
 #ifndef SQLITE_OMIT_FOREIGN_KEY
       if( db->flags&SQLITE_ForeignKeys ){
         /* Check that the column is not part of an FK child key definition. It
         ** is not necessary to check if it is part of a parent key, as parent
         ** key columns must be indexed. The check below will pick up this 
         ** case.  */
         FKey *pFKey;
         for(pFKey=pTab->pFKey; pFKey; pFKey=pFKey->pNextFrom){
           int j;
           for(j=0; j<pFKey->nCol; j++){
             if( pFKey->aCol[j].iFrom==iCol ){
               zFault = "foreign key";
             }
           }
         }
       }
 #endif
       for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
         int j;
         for(j=0; j<pIdx->nKeyCol; j++){
           if( pIdx->aiColumn[j]==iCol ){
             zFault = "indexed";
           }
         }
       }
       if( zFault ){
         sqlite3DbFree(db, zErr);
         zErr = sqlite3MPrintf(db, "cannot open %s column for writing", zFault);
         rc = SQLITE_ERROR;
         sqlite3BtreeLeaveAll(db);
         goto blob_open_out;
       }
     }
 
     pBlob->pStmt = (sqlite3_stmt *)sqlite3VdbeCreate(pParse);
     assert( pBlob->pStmt || db->mallocFailed );
     if( pBlob->pStmt ){
       Vdbe *v = (Vdbe *)pBlob->pStmt;
       int iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
 
 
       sqlite3VdbeAddOp4Int(v, OP_Transaction, iDb, flags, 
                            pTab->pSchema->schema_cookie,
                            pTab->pSchema->iGeneration);
       sqlite3VdbeChangeP5(v, 1);     
       sqlite3VdbeAddOpList(v, ArraySize(openBlob), openBlob, iLn);
 
       /* Make sure a mutex is held on the table to be accessed */
       sqlite3VdbeUsesBtree(v, iDb); 
 
       /* Configure the OP_TableLock instruction */
 #ifdef SQLITE_OMIT_SHARED_CACHE
       sqlite3VdbeChangeToNoop(v, 1);
 #else
       sqlite3VdbeChangeP1(v, 1, iDb);
       sqlite3VdbeChangeP2(v, 1, pTab->tnum);
       sqlite3VdbeChangeP3(v, 1, flags);
       sqlite3VdbeChangeP4(v, 1, pTab->zName, P4_TRANSIENT);
 #endif
 
       /* Remove either the OP_OpenWrite or OpenRead. Set the P2 
       ** parameter of the other to pTab->tnum.  */
       sqlite3VdbeChangeToNoop(v, 3 - flags);
       sqlite3VdbeChangeP2(v, 2 + flags, pTab->tnum);
       sqlite3VdbeChangeP3(v, 2 + flags, iDb);
 
       /* Configure the number of columns. Configure the cursor to
       ** think that the table has one more column than it really
       ** does. An OP_Column to retrieve this imaginary column will
       ** always return an SQL NULL. This is useful because it means
       ** we can invoke OP_Column to fill in the vdbe cursors type 
       ** and offset cache without causing any IO.
       */
       sqlite3VdbeChangeP4(v, 2+flags, SQLITE_INT_TO_PTR(pTab->nCol+1),P4_INT32);
       sqlite3VdbeChangeP2(v, 6, pTab->nCol);
       if( !db->mallocFailed ){
         pParse->nVar = 1;
         pParse->nMem = 1;
         pParse->nTab = 1;
         sqlite3VdbeMakeReady(v, pParse);
       }
     }
    
     pBlob->flags = flags;
     pBlob->iCol = iCol;
     pBlob->db = db;
     sqlite3BtreeLeaveAll(db);
     if( db->mallocFailed ){
       goto blob_open_out;
     }
     sqlite3_bind_int64(pBlob->pStmt, 1, iRow);
     rc = blobSeekToRow(pBlob, iRow, &zErr);
   } while( (++nAttempt)<SQLITE_MAX_SCHEMA_RETRY && rc==SQLITE_SCHEMA );
 
 blob_open_out:
   if( rc==SQLITE_OK && db->mallocFailed==0 ){
     *ppBlob = (sqlite3_blob *)pBlob;
   }else{
     if( pBlob && pBlob->pStmt ) sqlite3VdbeFinalize((Vdbe *)pBlob->pStmt);
     sqlite3DbFree(db, pBlob);
   }
   sqlite3ErrorWithMsg(db, rc, (zErr ? "%s" : 0), zErr);
   sqlite3DbFree(db, zErr);
   sqlite3ParserReset(pParse);
   sqlite3StackFree(db, pParse);
   rc = sqlite3ApiExit(db, rc);
   sqlite3_mutex_leave(db->mutex);
   return rc;
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_blob_read	(	sqlite3_blob *	pBlob,
		void *	Z,
		int	N,
		int	iOffset
	)

Definition at line 77866 of file sqlite3.c.

References sqlite3BtreeData().

                                                                                                  {
   return blobReadWrite(pBlob, z, n, iOffset, sqlite3BtreeData);
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_blob_reopen	(	sqlite3_blob *	pBlob,
		sqlite3_int64	iRow
	)

Definition at line 77898 of file sqlite3.c.

References Incrblob::db, sqlite3::mutex, Incrblob::pStmt, sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3ApiExit(), sqlite3DbFree(), and sqlite3ErrorWithMsg().

                                                                                           {
   int rc;
   Incrblob *p = (Incrblob *)pBlob;
   sqlite3 *db;
 
   if( p==0 ) return SQLITE_MISUSE_BKPT;
   db = p->db;
   sqlite3_mutex_enter(db->mutex);
 
   if( p->pStmt==0 ){
     /* If there is no statement handle, then the blob-handle has
     ** already been invalidated. Return SQLITE_ABORT in this case.
     */
     rc = SQLITE_ABORT;
   }else{
     char *zErr;
     rc = blobSeekToRow(p, iRow, &zErr);
     if( rc!=SQLITE_OK ){
       sqlite3ErrorWithMsg(db, rc, (zErr ? "%s" : 0), zErr);
       sqlite3DbFree(db, zErr);
     }
     assert( rc!=SQLITE_SCHEMA );
   }
 
   rc = sqlite3ApiExit(db, rc);
   assert( rc==SQLITE_OK || p->pStmt==0 );
   sqlite3_mutex_leave(db->mutex);
   return rc;
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_blob_write	(	sqlite3_blob *	pBlob,
		const void *	z,
		int	n,
		int	iOffset
	)

Definition at line 77873 of file sqlite3.c.

References sqlite3BtreePutData().

                                                                                                         {
   return blobReadWrite(pBlob, (void *)z, n, iOffset, sqlite3BtreePutData);
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_busy_handler	(	sqlite3 *	db,
		int()(void , int)	xBusy,
		void *	pArg
	)

Definition at line 129415 of file sqlite3.c.

References sqlite3::busyHandler, sqlite3::busyTimeout, sqlite3::mutex, BusyHandler::nBusy, BusyHandler::pArg, sqlite3_mutex_enter(), sqlite3_mutex_leave(), and BusyHandler::xFunc.

Referenced by sqlite3_busy_timeout().

  {
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
 #endif
   sqlite3_mutex_enter(db->mutex);
   db->busyHandler.xFunc = xBusy;
   db->busyHandler.pArg = pArg;
   db->busyHandler.nBusy = 0;
   db->busyTimeout = 0;
   sqlite3_mutex_leave(db->mutex);
   return SQLITE_OK;
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_busy_timeout	(	sqlite3 *	db,
		int	ms
	)

Definition at line 129469 of file sqlite3.c.

References sqlite3::busyTimeout, and sqlite3_busy_handler().

Referenced by sqlite3Pragma().

                                                                        {
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
 #endif
   if( ms>0 ){
     sqlite3_busy_handler(db, sqliteDefaultBusyCallback, (void*)db);
     db->busyTimeout = ms;
   }else{
     sqlite3_busy_handler(db, 0, 0);
   }
   return SQLITE_OK;
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_cancel_auto_extension ( void(*)(void) xEntryPoint )

Definition at line 103056 of file sqlite3.c.

References sqlite3_mutex_enter(), sqlite3_mutex_leave(), and sqlite3MutexAlloc().

                                                                                 {
 #if SQLITE_THREADSAFE
   sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER);
 #endif
   int i;
   int n = 0;
   wsdAutoextInit;
   sqlite3_mutex_enter(mutex);
   for(i=wsdAutoext.nExt-1; i>=0; i--){
     if( wsdAutoext.aExt[i]==xInit ){
       wsdAutoext.nExt--;
       wsdAutoext.aExt[i] = wsdAutoext.aExt[wsdAutoext.nExt];
       n++;
       break;
     }
   }
   sqlite3_mutex_leave(mutex);
   return n;
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_changes ( sqlite3 * db )

Definition at line 128852 of file sqlite3.c.

References sqlite3::nChange.

                                                           {
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(db) ){
     (void)SQLITE_MISUSE_BKPT;
     return 0;
   }
 #endif
   return db->nChange;
 }

SQLITE_API int SQLITE_STDCALL sqlite3_clear_bindings ( sqlite3_stmt * pStmt )

Definition at line 69116 of file sqlite3.c.

References Vdbe::aVar, Vdbe::db, Vdbe::expired, Vdbe::expmask, sqlite3_value::flags, Vdbe::isPrepareV2, sqlite3::mutex, Vdbe::nVar, sqlite3_mutex_enter(), sqlite3_mutex_leave(), and sqlite3VdbeMemRelease().

                                                                          {
   int i;
   int rc = SQLITE_OK;
   Vdbe *p = (Vdbe*)pStmt;
 #if SQLITE_THREADSAFE
   sqlite3_mutex *mutex = ((Vdbe*)pStmt)->db->mutex;
 #endif
   sqlite3_mutex_enter(mutex);
   for(i=0; i<p->nVar; i++){
     sqlite3VdbeMemRelease(&p->aVar[i]);
     p->aVar[i].flags = MEM_Null;
   }
   if( p->isPrepareV2 && p->expmask ){
     p->expired = 1;
   }
   sqlite3_mutex_leave(mutex);
   return rc;
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_close ( sqlite3 * db )

Definition at line 129007 of file sqlite3.c.

129007 { return sqlite3Close(db,0); }

SQLITE_API int SQLITE_STDCALL sqlite3_close_v2 ( sqlite3 * db )

Definition at line 129008 of file sqlite3.c.

129008 { return sqlite3Close(db,1); }

SQLITE_API int SQLITE_STDCALL sqlite3_collation_needed	(	sqlite3 *	db,
		void *	pCollNeededArg,
		void()(void , sqlite3 , int eTextRep, const char )	xCollNeeded
	)

Definition at line 131035 of file sqlite3.c.

References sqlite3::mutex, sqlite3::pCollNeededArg, sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3::xCollNeeded, and sqlite3::xCollNeeded16.

  {
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
 #endif
   sqlite3_mutex_enter(db->mutex);
   db->xCollNeeded = xCollNeeded;
   db->xCollNeeded16 = 0;
   db->pCollNeededArg = pCollNeededArg;
   sqlite3_mutex_leave(db->mutex);
   return SQLITE_OK;
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_collation_needed16	(	sqlite3 *	db,
		void *	pCollNeededArg,
		void()(void , sqlite3 , int eTextRep, const void )	xCollNeeded16
	)

Definition at line 131056 of file sqlite3.c.

References sqlite3::mutex, sqlite3::pCollNeededArg, sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3::xCollNeeded, and sqlite3::xCollNeeded16.

  {
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
 #endif
   sqlite3_mutex_enter(db->mutex);
   db->xCollNeeded = 0;
   db->xCollNeeded16 = xCollNeeded16;
   db->pCollNeededArg = pCollNeededArg;
   sqlite3_mutex_leave(db->mutex);
   return SQLITE_OK;
 }

Here is the call graph for this function:

SQLITE_API const void *SQLITE_STDCALL sqlite3_column_blob	(	sqlite3_stmt *	pStmt,
		int	iCol
	)

Definition at line 69923 of file sqlite3.c.

References sqlite3_value_blob().

                                                                                      {
   const void *val;
   val = sqlite3_value_blob( columnMem(pStmt,i) );
   /* Even though there is no encoding conversion, value_blob() might
   ** need to call malloc() to expand the result of a zeroblob() 
   ** expression. 
   */
   columnMallocFailure(pStmt);
   return val;
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_column_bytes	(	sqlite3_stmt *	pStmt,
		int	iCol
	)

Definition at line 69933 of file sqlite3.c.

References sqlite3_value_bytes().

                                                                               {
   int val = sqlite3_value_bytes( columnMem(pStmt,i) );
   columnMallocFailure(pStmt);
   return val;
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_column_bytes16	(	sqlite3_stmt *	pStmt,
		int	iCol
	)

Definition at line 69938 of file sqlite3.c.

References sqlite3_value_bytes16().

                                                                                 {
   int val = sqlite3_value_bytes16( columnMem(pStmt,i) );
   columnMallocFailure(pStmt);
   return val;
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_column_count ( sqlite3_stmt * pStmt )

Definition at line 69812 of file sqlite3.c.

References Vdbe::nResColumn.

Referenced by sqlite3_exec().

                                                                        {
   Vdbe *pVm = (Vdbe *)pStmt;
   return pVm ? pVm->nResColumn : 0;
 }

SQLITE_API const char* SQLITE_STDCALL sqlite3_column_database_name	(	sqlite3_stmt *	,
		int
	)

SQLITE_API const void* SQLITE_STDCALL sqlite3_column_database_name16	(	sqlite3_stmt *	,
		int
	)

SQLITE_API const char *SQLITE_STDCALL sqlite3_column_decltype	(	sqlite3_stmt *	pStmt,
		int	N
	)

Definition at line 70068 of file sqlite3.c.

                                                                                          {
   return columnName(
       pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_DECLTYPE);
 }

SQLITE_API const void *SQLITE_STDCALL sqlite3_column_decltype16	(	sqlite3_stmt *	pStmt,
		int	N
	)

Definition at line 70073 of file sqlite3.c.

References sqlite3_value_text16().

                                                                                            {
   return columnName(
       pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_DECLTYPE);
 }

Here is the call graph for this function:

SQLITE_API double SQLITE_STDCALL sqlite3_column_double	(	sqlite3_stmt *	pStmt,
		int	iCol
	)

Definition at line 69943 of file sqlite3.c.

References sqlite3_value_double().

                                                                                   {
   double val = sqlite3_value_double( columnMem(pStmt,i) );
   columnMallocFailure(pStmt);
   return val;
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_column_int	(	sqlite3_stmt *	pStmt,
		int	iCol
	)

Definition at line 69948 of file sqlite3.c.

References sqlite3_value_int().

                                                                             {
   int val = sqlite3_value_int( columnMem(pStmt,i) );
   columnMallocFailure(pStmt);
   return val;
 }

Here is the call graph for this function:

SQLITE_API sqlite_int64 SQLITE_STDCALL sqlite3_column_int64	(	sqlite3_stmt *	pStmt,
		int	iCol
	)

Definition at line 69953 of file sqlite3.c.

References sqlite3_value_int64().

                                                                                        {
   sqlite_int64 val = sqlite3_value_int64( columnMem(pStmt,i) );
   columnMallocFailure(pStmt);
   return val;
 }

Here is the call graph for this function:

SQLITE_API const char *SQLITE_STDCALL sqlite3_column_name	(	sqlite3_stmt *	pStmt,
		int	N
	)

Definition at line 70043 of file sqlite3.c.

Referenced by sqlite3_exec().

                                                                                      {
   return columnName(
       pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_NAME);
 }

SQLITE_API const void *SQLITE_STDCALL sqlite3_column_name16	(	sqlite3_stmt *	pStmt,
		int	N
	)

Definition at line 70048 of file sqlite3.c.

References sqlite3_value_text16().

                                                                                        {
   return columnName(
       pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_NAME);
 }

Here is the call graph for this function:

SQLITE_API const char* SQLITE_STDCALL sqlite3_column_origin_name	(	sqlite3_stmt *	,
		int
	)

SQLITE_API const void* SQLITE_STDCALL sqlite3_column_origin_name16	(	sqlite3_stmt *	,
		int
	)

SQLITE_API const char* SQLITE_STDCALL sqlite3_column_table_name	(	sqlite3_stmt *	,
		int
	)

SQLITE_API const void* SQLITE_STDCALL sqlite3_column_table_name16	(	sqlite3_stmt *	,
		int
	)

SQLITE_API const unsigned char *SQLITE_STDCALL sqlite3_column_text	(	sqlite3_stmt *	pStmt,
		int	iCol
	)

Definition at line 69958 of file sqlite3.c.

References sqlite3_value_text().

Referenced by sqlite3_exec().

                                                                                               {
   const unsigned char *val = sqlite3_value_text( columnMem(pStmt,i) );
   columnMallocFailure(pStmt);
   return val;
 }

Here is the call graph for this function:

SQLITE_API const void *SQLITE_STDCALL sqlite3_column_text16	(	sqlite3_stmt *	pStmt,
		int	iCol
	)

Definition at line 69973 of file sqlite3.c.

References sqlite3_value_text16().

                                                                                        {
   const void *val = sqlite3_value_text16( columnMem(pStmt,i) );
   columnMallocFailure(pStmt);
   return val;
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_column_type	(	sqlite3_stmt *	pStmt,
		int	iCol
	)

Definition at line 69979 of file sqlite3.c.

References sqlite3_value_type().

Referenced by sqlite3_exec().

                                                                              {
   int iType = sqlite3_value_type( columnMem(pStmt,i) );
   columnMallocFailure(pStmt);
   return iType;
 }

Here is the call graph for this function:

SQLITE_API sqlite3_value *SQLITE_STDCALL sqlite3_column_value	(	sqlite3_stmt *	pStmt,
		int	iCol
	)

Definition at line 69963 of file sqlite3.c.

References sqlite3_value::flags.

                                                                                          {
   Mem *pOut = columnMem(pStmt, i);
   if( pOut->flags&MEM_Static ){
     pOut->flags &= ~MEM_Static;
     pOut->flags |= MEM_Ephem;
   }
   columnMallocFailure(pStmt);
   return (sqlite3_value *)pOut;
 }

SQLITE_API void *SQLITE_STDCALL sqlite3_commit_hook	(	sqlite3 *	db,
		int()(void )	xCallback,
		void *	pArg
	)

Definition at line 129782 of file sqlite3.c.

References sqlite3::mutex, sqlite3::pCommitArg, sqlite3_mutex_enter(), sqlite3_mutex_leave(), and sqlite3::xCommitCallback.

  {
   void *pOld;
 
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(db) ){
     (void)SQLITE_MISUSE_BKPT;
     return 0;
   }
 #endif
   sqlite3_mutex_enter(db->mutex);
   pOld = db->pCommitArg;
   db->xCommitCallback = xCallback;
   db->pCommitArg = pArg;
   sqlite3_mutex_leave(db->mutex);
   return pOld;
 }

Here is the call graph for this function:

SQLITE_API const char *SQLITE_STDCALL sqlite3_compileoption_get ( int N )

Definition at line 14472 of file sqlite3.c.

Referenced by sqlite3Pragma().

                                                                       {
   if( N>=0 && N<ArraySize(azCompileOpt) ){
     return azCompileOpt[N];
   }
   return 0;
 }

SQLITE_API int SQLITE_STDCALL sqlite3_compileoption_used ( const char * zOptName )

Definition at line 14444 of file sqlite3.c.

References sqlite3_strnicmp(), sqlite3IsIdChar(), and sqlite3Strlen30().

                                                                               {
   int i, n;
 
 #if SQLITE_ENABLE_API_ARMOR
   if( zOptName==0 ){
     (void)SQLITE_MISUSE_BKPT;
     return 0;
   }
 #endif
   if( sqlite3StrNICmp(zOptName, "SQLITE_", 7)==0 ) zOptName += 7;
   n = sqlite3Strlen30(zOptName);
 
   /* Since ArraySize(azCompileOpt) is normally in single digits, a
   ** linear search is adequate.  No need for a binary search. */
   for(i=0; i<ArraySize(azCompileOpt); i++){
     if( sqlite3StrNICmp(zOptName, azCompileOpt[i], n)==0
      && sqlite3IsIdChar((unsigned char)azCompileOpt[i][n])==0
     ){
       return 1;
     }
   }
   return 0;
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_complete ( const char * sql )

Definition at line 127718 of file sqlite3.c.

References sqlite3_strnicmp().

Referenced by sqlite3_complete16().

                                                                 {
   u8 state = 0;   /* Current state, using numbers defined in header comment */
   u8 token;       /* Value of the next token */
 
 #ifndef SQLITE_OMIT_TRIGGER
   /* A complex statement machine used to detect the end of a CREATE TRIGGER
   ** statement.  This is the normal case.
   */
   static const u8 trans[8][8] = {
                      /* Token:                                                */
      /* State:       **  SEMI  WS  OTHER  EXPLAIN  CREATE  TEMP  TRIGGER  END */
      /* 0 INVALID: */ {    1,  0,     2,       3,      4,    2,       2,   2, },
      /* 1   START: */ {    1,  1,     2,       3,      4,    2,       2,   2, },
      /* 2  NORMAL: */ {    1,  2,     2,       2,      2,    2,       2,   2, },
      /* 3 EXPLAIN: */ {    1,  3,     3,       2,      4,    2,       2,   2, },
      /* 4  CREATE: */ {    1,  4,     2,       2,      2,    4,       5,   2, },
      /* 5 TRIGGER: */ {    6,  5,     5,       5,      5,    5,       5,   5, },
      /* 6    SEMI: */ {    6,  6,     5,       5,      5,    5,       5,   7, },
      /* 7     END: */ {    1,  7,     5,       5,      5,    5,       5,   5, },
   };
 #else
   /* If triggers are not supported by this compile then the statement machine
   ** used to detect the end of a statement is much simpler
   */
   static const u8 trans[3][3] = {
                      /* Token:           */
      /* State:       **  SEMI  WS  OTHER */
      /* 0 INVALID: */ {    1,  0,     2, },
      /* 1   START: */ {    1,  1,     2, },
      /* 2  NORMAL: */ {    1,  2,     2, },
   };
 #endif /* SQLITE_OMIT_TRIGGER */
 
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( zSql==0 ){
     (void)SQLITE_MISUSE_BKPT;
     return 0;
   }
 #endif
 
   while( *zSql ){
     switch( *zSql ){
       case ';': {  /* A semicolon */
         token = tkSEMI;
         break;
       }
       case ' ':
       case '\r':
       case '\t':
       case '\n':
       case '\f': {  /* White space is ignored */
         token = tkWS;
         break;
       }
       case '/': {   /* C-style comments */
         if( zSql[1]!='*' ){
           token = tkOTHER;
           break;
         }
         zSql += 2;
         while( zSql[0] && (zSql[0]!='*' || zSql[1]!='/') ){ zSql++; }
         if( zSql[0]==0 ) return 0;
         zSql++;
         token = tkWS;
         break;
       }
       case '-': {   /* SQL-style comments from "--" to end of line */
         if( zSql[1]!='-' ){
           token = tkOTHER;
           break;
         }
         while( *zSql && *zSql!='\n' ){ zSql++; }
         if( *zSql==0 ) return state==1;
         token = tkWS;
         break;
       }
       case '[': {   /* Microsoft-style identifiers in [...] */
         zSql++;
         while( *zSql && *zSql!=']' ){ zSql++; }
         if( *zSql==0 ) return 0;
         token = tkOTHER;
         break;
       }
       case '`':     /* Grave-accent quoted symbols used by MySQL */
       case '"':     /* single- and double-quoted strings */
       case '\'': {
         int c = *zSql;
         zSql++;
         while( *zSql && *zSql!=c ){ zSql++; }
         if( *zSql==0 ) return 0;
         token = tkOTHER;
         break;
       }
       default: {
 #ifdef SQLITE_EBCDIC
         unsigned char c;
 #endif
         if( IdChar((u8)*zSql) ){
           /* Keywords and unquoted identifiers */
           int nId;
           for(nId=1; IdChar(zSql[nId]); nId++){}
 #ifdef SQLITE_OMIT_TRIGGER
           token = tkOTHER;
 #else
           switch( *zSql ){
             case 'c': case 'C': {
               if( nId==6 && sqlite3StrNICmp(zSql, "create", 6)==0 ){
                 token = tkCREATE;
               }else{
                 token = tkOTHER;
               }
               break;
             }
             case 't': case 'T': {
               if( nId==7 && sqlite3StrNICmp(zSql, "trigger", 7)==0 ){
                 token = tkTRIGGER;
               }else if( nId==4 && sqlite3StrNICmp(zSql, "temp", 4)==0 ){
                 token = tkTEMP;
               }else if( nId==9 && sqlite3StrNICmp(zSql, "temporary", 9)==0 ){
                 token = tkTEMP;
               }else{
                 token = tkOTHER;
               }
               break;
             }
             case 'e':  case 'E': {
               if( nId==3 && sqlite3StrNICmp(zSql, "end", 3)==0 ){
                 token = tkEND;
               }else
 #ifndef SQLITE_OMIT_EXPLAIN
               if( nId==7 && sqlite3StrNICmp(zSql, "explain", 7)==0 ){
                 token = tkEXPLAIN;
               }else
 #endif
               {
                 token = tkOTHER;
               }
               break;
             }
             default: {
               token = tkOTHER;
               break;
             }
           }
 #endif /* SQLITE_OMIT_TRIGGER */
           zSql += nId-1;
         }else{
           /* Operators and special symbols */
           token = tkOTHER;
         }
         break;
       }
     }
     state = trans[state][token];
     zSql++;
   }
   return state==1;
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_complete16 ( const void * sql )

Definition at line 127883 of file sqlite3.c.

References sqlite3_complete(), sqlite3_initialize(), sqlite3ApiExit(), sqlite3ValueFree(), sqlite3ValueNew(), and sqlite3ValueSetStr().

                                                                   {
   sqlite3_value *pVal;
   char const *zSql8;
   int rc;
 
 #ifndef SQLITE_OMIT_AUTOINIT
   rc = sqlite3_initialize();
   if( rc ) return rc;
 #endif
   pVal = sqlite3ValueNew(0);
   sqlite3ValueSetStr(pVal, -1, zSql, SQLITE_UTF16NATIVE, SQLITE_STATIC);
   zSql8 = sqlite3ValueText(pVal, SQLITE_UTF8);
   if( zSql8 ){
     rc = sqlite3_complete(zSql8);
   }else{
     rc = SQLITE_NOMEM;
   }
   sqlite3ValueFree(pVal);
   return sqlite3ApiExit(0, rc);
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_CDECL sqlite3_config	(	int	op,
			...
	)

Definition at line 128326 of file sqlite3.c.

References Sqlite3Config::bCoreMutex, Sqlite3Config::bFullMutex, Sqlite3Config::isInit, Sqlite3Config::m, Sqlite3Config::mxMmap, Sqlite3Config::pcache2, sqlite3MemSetDefault(), sqlite3PCacheSetDefault(), Sqlite3Config::szMmap, sqlite3_pcache_methods2::xInit, and sqlite3_mem_methods::xMalloc.

Referenced by sqlite3MemSetDefault(), and sqlite3PCacheSetDefault().

                                                        {
   va_list ap;
   int rc = SQLITE_OK;
 
   /* sqlite3_config() shall return SQLITE_MISUSE if it is invoked while
   ** the SQLite library is in use. */
   if( sqlite3GlobalConfig.isInit ) return SQLITE_MISUSE_BKPT;
 
   va_start(ap, op);
   switch( op ){
 
     /* Mutex configuration options are only available in a threadsafe
     ** compile.
     */
 #if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0  /* IMP: R-54466-46756 */
     case SQLITE_CONFIG_SINGLETHREAD: {
       /* EVIDENCE-OF: R-02748-19096 This option sets the threading mode to
       ** Single-thread. */
       sqlite3GlobalConfig.bCoreMutex = 0;  /* Disable mutex on core */
       sqlite3GlobalConfig.bFullMutex = 0;  /* Disable mutex on connections */
       break;
     }
 #endif
 #if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0 /* IMP: R-20520-54086 */
     case SQLITE_CONFIG_MULTITHREAD: {
       /* EVIDENCE-OF: R-14374-42468 This option sets the threading mode to
       ** Multi-thread. */
       sqlite3GlobalConfig.bCoreMutex = 1;  /* Enable mutex on core */
       sqlite3GlobalConfig.bFullMutex = 0;  /* Disable mutex on connections */
       break;
     }
 #endif
 #if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0 /* IMP: R-59593-21810 */
     case SQLITE_CONFIG_SERIALIZED: {
       /* EVIDENCE-OF: R-41220-51800 This option sets the threading mode to
       ** Serialized. */
       sqlite3GlobalConfig.bCoreMutex = 1;  /* Enable mutex on core */
       sqlite3GlobalConfig.bFullMutex = 1;  /* Enable mutex on connections */
       break;
     }
 #endif
 #if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0 /* IMP: R-63666-48755 */
     case SQLITE_CONFIG_MUTEX: {
       /* Specify an alternative mutex implementation */
       sqlite3GlobalConfig.mutex = *va_arg(ap, sqlite3_mutex_methods*);
       break;
     }
 #endif
 #if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0 /* IMP: R-14450-37597 */
     case SQLITE_CONFIG_GETMUTEX: {
       /* Retrieve the current mutex implementation */
       *va_arg(ap, sqlite3_mutex_methods*) = sqlite3GlobalConfig.mutex;
       break;
     }
 #endif
 
     case SQLITE_CONFIG_MALLOC: {
       /* EVIDENCE-OF: R-55594-21030 The SQLITE_CONFIG_MALLOC option takes a
       ** single argument which is a pointer to an instance of the
       ** sqlite3_mem_methods structure. The argument specifies alternative
       ** low-level memory allocation routines to be used in place of the memory
       ** allocation routines built into SQLite. */
       sqlite3GlobalConfig.m = *va_arg(ap, sqlite3_mem_methods*);
       break;
     }
     case SQLITE_CONFIG_GETMALLOC: {
       /* EVIDENCE-OF: R-51213-46414 The SQLITE_CONFIG_GETMALLOC option takes a
       ** single argument which is a pointer to an instance of the
       ** sqlite3_mem_methods structure. The sqlite3_mem_methods structure is
       ** filled with the currently defined memory allocation routines. */
       if( sqlite3GlobalConfig.m.xMalloc==0 ) sqlite3MemSetDefault();
       *va_arg(ap, sqlite3_mem_methods*) = sqlite3GlobalConfig.m;
       break;
     }
     case SQLITE_CONFIG_MEMSTATUS: {
       /* EVIDENCE-OF: R-61275-35157 The SQLITE_CONFIG_MEMSTATUS option takes
       ** single argument of type int, interpreted as a boolean, which enables
       ** or disables the collection of memory allocation statistics. */
       sqlite3GlobalConfig.bMemstat = va_arg(ap, int);
       break;
     }
     case SQLITE_CONFIG_SCRATCH: {
       /* EVIDENCE-OF: R-08404-60887 There are three arguments to
       ** SQLITE_CONFIG_SCRATCH: A pointer an 8-byte aligned memory buffer from
       ** which the scratch allocations will be drawn, the size of each scratch
       ** allocation (sz), and the maximum number of scratch allocations (N). */
       sqlite3GlobalConfig.pScratch = va_arg(ap, void*);
       sqlite3GlobalConfig.szScratch = va_arg(ap, int);
       sqlite3GlobalConfig.nScratch = va_arg(ap, int);
       break;
     }
     case SQLITE_CONFIG_PAGECACHE: {
       /* EVIDENCE-OF: R-31408-40510 There are three arguments to
       ** SQLITE_CONFIG_PAGECACHE: A pointer to 8-byte aligned memory, the size
       ** of each page buffer (sz), and the number of pages (N). */
       sqlite3GlobalConfig.pPage = va_arg(ap, void*);
       sqlite3GlobalConfig.szPage = va_arg(ap, int);
       sqlite3GlobalConfig.nPage = va_arg(ap, int);
       break;
     }
     case SQLITE_CONFIG_PCACHE_HDRSZ: {
       /* EVIDENCE-OF: R-39100-27317 The SQLITE_CONFIG_PCACHE_HDRSZ option takes
       ** a single parameter which is a pointer to an integer and writes into
       ** that integer the number of extra bytes per page required for each page
       ** in SQLITE_CONFIG_PAGECACHE. */
       *va_arg(ap, int*) = 
           sqlite3HeaderSizeBtree() +
           sqlite3HeaderSizePcache() +
           sqlite3HeaderSizePcache1();
       break;
     }
 
     case SQLITE_CONFIG_PCACHE: {
       /* no-op */
       break;
     }
     case SQLITE_CONFIG_GETPCACHE: {
       /* now an error */
       rc = SQLITE_ERROR;
       break;
     }
 
     case SQLITE_CONFIG_PCACHE2: {
       /* EVIDENCE-OF: R-63325-48378 The SQLITE_CONFIG_PCACHE2 option takes a
       ** single argument which is a pointer to an sqlite3_pcache_methods2
       ** object. This object specifies the interface to a custom page cache
       ** implementation. */
       sqlite3GlobalConfig.pcache2 = *va_arg(ap, sqlite3_pcache_methods2*);
       break;
     }
     case SQLITE_CONFIG_GETPCACHE2: {
       /* EVIDENCE-OF: R-22035-46182 The SQLITE_CONFIG_GETPCACHE2 option takes a
       ** single argument which is a pointer to an sqlite3_pcache_methods2
       ** object. SQLite copies of the current page cache implementation into
       ** that object. */
       if( sqlite3GlobalConfig.pcache2.xInit==0 ){
         sqlite3PCacheSetDefault();
       }
       *va_arg(ap, sqlite3_pcache_methods2*) = sqlite3GlobalConfig.pcache2;
       break;
     }
 
 /* EVIDENCE-OF: R-06626-12911 The SQLITE_CONFIG_HEAP option is only
 ** available if SQLite is compiled with either SQLITE_ENABLE_MEMSYS3 or
 ** SQLITE_ENABLE_MEMSYS5 and returns SQLITE_ERROR if invoked otherwise. */
 #if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5)
     case SQLITE_CONFIG_HEAP: {
       /* EVIDENCE-OF: R-19854-42126 There are three arguments to
       ** SQLITE_CONFIG_HEAP: An 8-byte aligned pointer to the memory, the
       ** number of bytes in the memory buffer, and the minimum allocation size.
       */
       sqlite3GlobalConfig.pHeap = va_arg(ap, void*);
       sqlite3GlobalConfig.nHeap = va_arg(ap, int);
       sqlite3GlobalConfig.mnReq = va_arg(ap, int);
 
       if( sqlite3GlobalConfig.mnReq<1 ){
         sqlite3GlobalConfig.mnReq = 1;
       }else if( sqlite3GlobalConfig.mnReq>(1<<12) ){
         /* cap min request size at 2^12 */
         sqlite3GlobalConfig.mnReq = (1<<12);
       }
 
       if( sqlite3GlobalConfig.pHeap==0 ){
         /* EVIDENCE-OF: R-49920-60189 If the first pointer (the memory pointer)
         ** is NULL, then SQLite reverts to using its default memory allocator
         ** (the system malloc() implementation), undoing any prior invocation of
         ** SQLITE_CONFIG_MALLOC.
         **
         ** Setting sqlite3GlobalConfig.m to all zeros will cause malloc to
         ** revert to its default implementation when sqlite3_initialize() is run
         */
         memset(&sqlite3GlobalConfig.m, 0, sizeof(sqlite3GlobalConfig.m));
       }else{
         /* EVIDENCE-OF: R-61006-08918 If the memory pointer is not NULL then the
         ** alternative memory allocator is engaged to handle all of SQLites
         ** memory allocation needs. */
 #ifdef SQLITE_ENABLE_MEMSYS3
         sqlite3GlobalConfig.m = *sqlite3MemGetMemsys3();
 #endif
 #ifdef SQLITE_ENABLE_MEMSYS5
         sqlite3GlobalConfig.m = *sqlite3MemGetMemsys5();
 #endif
       }
       break;
     }
 #endif
 
     case SQLITE_CONFIG_LOOKASIDE: {
       sqlite3GlobalConfig.szLookaside = va_arg(ap, int);
       sqlite3GlobalConfig.nLookaside = va_arg(ap, int);
       break;
     }
     
     /* Record a pointer to the logger function and its first argument.
     ** The default is NULL.  Logging is disabled if the function pointer is
     ** NULL.
     */
     case SQLITE_CONFIG_LOG: {
       /* MSVC is picky about pulling func ptrs from va lists.
       ** http://support.microsoft.com/kb/47961
       ** sqlite3GlobalConfig.xLog = va_arg(ap, void(*)(void*,int,const char*));
       */
       typedef void(*LOGFUNC_t)(void*,int,const char*);
       sqlite3GlobalConfig.xLog = va_arg(ap, LOGFUNC_t);
       sqlite3GlobalConfig.pLogArg = va_arg(ap, void*);
       break;
     }
 
     /* EVIDENCE-OF: R-55548-33817 The compile-time setting for URI filenames
     ** can be changed at start-time using the
     ** sqlite3_config(SQLITE_CONFIG_URI,1) or
     ** sqlite3_config(SQLITE_CONFIG_URI,0) configuration calls.
     */
     case SQLITE_CONFIG_URI: {
       /* EVIDENCE-OF: R-25451-61125 The SQLITE_CONFIG_URI option takes a single
       ** argument of type int. If non-zero, then URI handling is globally
       ** enabled. If the parameter is zero, then URI handling is globally
       ** disabled. */
       sqlite3GlobalConfig.bOpenUri = va_arg(ap, int);
       break;
     }
 
     case SQLITE_CONFIG_COVERING_INDEX_SCAN: {
       /* EVIDENCE-OF: R-36592-02772 The SQLITE_CONFIG_COVERING_INDEX_SCAN
       ** option takes a single integer argument which is interpreted as a
       ** boolean in order to enable or disable the use of covering indices for
       ** full table scans in the query optimizer. */
       sqlite3GlobalConfig.bUseCis = va_arg(ap, int);
       break;
     }
 
 #ifdef SQLITE_ENABLE_SQLLOG
     case SQLITE_CONFIG_SQLLOG: {
       typedef void(*SQLLOGFUNC_t)(void*, sqlite3*, const char*, int);
       sqlite3GlobalConfig.xSqllog = va_arg(ap, SQLLOGFUNC_t);
       sqlite3GlobalConfig.pSqllogArg = va_arg(ap, void *);
       break;
     }
 #endif
 
     case SQLITE_CONFIG_MMAP_SIZE: {
       /* EVIDENCE-OF: R-58063-38258 SQLITE_CONFIG_MMAP_SIZE takes two 64-bit
       ** integer (sqlite3_int64) values that are the default mmap size limit
       ** (the default setting for PRAGMA mmap_size) and the maximum allowed
       ** mmap size limit. */
       sqlite3_int64 szMmap = va_arg(ap, sqlite3_int64);
       sqlite3_int64 mxMmap = va_arg(ap, sqlite3_int64);
       /* EVIDENCE-OF: R-53367-43190 If either argument to this option is
       ** negative, then that argument is changed to its compile-time default.
       **
       ** EVIDENCE-OF: R-34993-45031 The maximum allowed mmap size will be
       ** silently truncated if necessary so that it does not exceed the
       ** compile-time maximum mmap size set by the SQLITE_MAX_MMAP_SIZE
       ** compile-time option.
       */
       if( mxMmap<0 || mxMmap>SQLITE_MAX_MMAP_SIZE ){
         mxMmap = SQLITE_MAX_MMAP_SIZE;
       }
       if( szMmap<0 ) szMmap = SQLITE_DEFAULT_MMAP_SIZE;
       if( szMmap>mxMmap) szMmap = mxMmap;
       sqlite3GlobalConfig.mxMmap = mxMmap;
       sqlite3GlobalConfig.szMmap = szMmap;
       break;
     }
 
 #if SQLITE_OS_WIN && defined(SQLITE_WIN32_MALLOC) /* IMP: R-04780-55815 */
     case SQLITE_CONFIG_WIN32_HEAPSIZE: {
       /* EVIDENCE-OF: R-34926-03360 SQLITE_CONFIG_WIN32_HEAPSIZE takes a 32-bit
       ** unsigned integer value that specifies the maximum size of the created
       ** heap. */
       sqlite3GlobalConfig.nHeap = va_arg(ap, int);
       break;
     }
 #endif
 
     case SQLITE_CONFIG_PMASZ: {
       sqlite3GlobalConfig.szPma = va_arg(ap, unsigned int);
       break;
     }
 
     default: {
       rc = SQLITE_ERROR;
       break;
     }
   }
   va_end(ap);
   return rc;
 }

Here is the call graph for this function:

SQLITE_API sqlite3 *SQLITE_STDCALL sqlite3_context_db_handle ( sqlite3_context * p )

Definition at line 69636 of file sqlite3.c.

References sqlite3_value::db, and sqlite3_context::pOut.

                                                                                 {
   assert( p && p->pFunc );
   return p->pOut->db;
 }

SQLITE_API int SQLITE_STDCALL sqlite3_create_collation	(	sqlite3 *	db,
		const char *	zName,
		int	eTextRep,
		void *	pArg,
		int()(void , int, const void , int, const void )	xCompare
	)

Definition at line 130967 of file sqlite3.c.

References sqlite3_create_collation_v2().

  {
   return sqlite3_create_collation_v2(db, zName, enc, pCtx, xCompare, 0);
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_create_collation16	(	sqlite3 *	db,
		const void *	zName,
		int	eTextRep,
		void *	pArg,
		int()(void , int, const void , int, const void )	xCompare
	)

Definition at line 131005 of file sqlite3.c.

References sqlite3::mutex, sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3ApiExit(), sqlite3DbFree(), and sqlite3Utf16to8().

  {
   int rc = SQLITE_OK;
   char *zName8;
 
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(db) || zName==0 ) return SQLITE_MISUSE_BKPT;
 #endif
   sqlite3_mutex_enter(db->mutex);
   assert( !db->mallocFailed );
   zName8 = sqlite3Utf16to8(db, zName, -1, SQLITE_UTF16NATIVE);
   if( zName8 ){
     rc = createCollation(db, zName8, (u8)enc, pCtx, xCompare, 0);
     sqlite3DbFree(db, zName8);
   }
   rc = sqlite3ApiExit(db, rc);
   sqlite3_mutex_leave(db->mutex);
   return rc;
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_create_collation_v2	(	sqlite3 *	db,
		const char *	zName,
		int	eTextRep,
		void *	pArg,
		int()(void , int, const void , int, const void )	xCompare,
		void()(void )	xDestroy
	)

Definition at line 130980 of file sqlite3.c.

References sqlite3::mutex, sqlite3_mutex_enter(), sqlite3_mutex_leave(), and sqlite3ApiExit().

Referenced by sqlite3_create_collation().

  {
   int rc;
 
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(db) || zName==0 ) return SQLITE_MISUSE_BKPT;
 #endif
   sqlite3_mutex_enter(db->mutex);
   assert( !db->mallocFailed );
   rc = createCollation(db, zName, (u8)enc, pCtx, xCompare, xDel);
   rc = sqlite3ApiExit(db, rc);
   sqlite3_mutex_leave(db->mutex);
   return rc;
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_create_function	(	sqlite3 *	db,
		const char *	zFunctionName,
		int	nArg,
		int	eTextRep,
		void *	pApp,
		void()(sqlite3_context , int, sqlite3_value **)	xFunc,
		void()(sqlite3_context , int, sqlite3_value **)	xStep,
		void()(sqlite3_context )	xFinal
	)

Definition at line 129602 of file sqlite3.c.

References sqlite3_create_function_v2().

  {
   return sqlite3_create_function_v2(db, zFunc, nArg, enc, p, xFunc, xStep,
                                     xFinal, 0);
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_create_function16	(	sqlite3 *	db,
		const void *	zFunctionName,
		int	nArg,
		int	eTextRep,
		void *	pApp,
		void()(sqlite3_context , int, sqlite3_value **)	xFunc,
		void()(sqlite3_context , int, sqlite3_value **)	xStep,
		void()(sqlite3_context )	xFinal
	)

Definition at line 129659 of file sqlite3.c.

References sqlite3::mutex, sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3ApiExit(), sqlite3CreateFunc(), sqlite3DbFree(), and sqlite3Utf16to8().

  {
   int rc;
   char *zFunc8;
 
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(db) || zFunctionName==0 ) return SQLITE_MISUSE_BKPT;
 #endif
   sqlite3_mutex_enter(db->mutex);
   assert( !db->mallocFailed );
   zFunc8 = sqlite3Utf16to8(db, zFunctionName, -1, SQLITE_UTF16NATIVE);
   rc = sqlite3CreateFunc(db, zFunc8, nArg, eTextRep, p, xFunc, xStep, xFinal,0);
   sqlite3DbFree(db, zFunc8);
   rc = sqlite3ApiExit(db, rc);
   sqlite3_mutex_leave(db->mutex);
   return rc;
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_create_function_v2	(	sqlite3 *	db,
		const char *	zFunctionName,
		int	nArg,
		int	eTextRep,
		void *	pApp,
		void()(sqlite3_context , int, sqlite3_value **)	xFunc,
		void()(sqlite3_context , int, sqlite3_value **)	xStep,
		void()(sqlite3_context )	xFinal,
		void()(void )	xDestroy
	)

Definition at line 129616 of file sqlite3.c.

References sqlite3::mutex, FuncDestructor::nRef, FuncDestructor::pUserData, sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3ApiExit(), sqlite3CreateFunc(), sqlite3DbFree(), sqlite3DbMallocZero(), and FuncDestructor::xDestroy.

Referenced by sqlite3_create_function().

  {
   int rc = SQLITE_ERROR;
   FuncDestructor *pArg = 0;
 
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(db) ){
     return SQLITE_MISUSE_BKPT;
   }
 #endif
   sqlite3_mutex_enter(db->mutex);
   if( xDestroy ){
     pArg = (FuncDestructor *)sqlite3DbMallocZero(db, sizeof(FuncDestructor));
     if( !pArg ){
       xDestroy(p);
       goto out;
     }
     pArg->xDestroy = xDestroy;
     pArg->pUserData = p;
   }
   rc = sqlite3CreateFunc(db, zFunc, nArg, enc, p, xFunc, xStep, xFinal, pArg);
   if( pArg && pArg->nRef==0 ){
     assert( rc!=SQLITE_OK );
     xDestroy(p);
     sqlite3DbFree(db, pArg);
   }
 
  out:
   rc = sqlite3ApiExit(db, rc);
   sqlite3_mutex_leave(db->mutex);
   return rc;
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_create_module	(	sqlite3 *	db,
		const char *	zName,
		const sqlite3_module *	p,
		void *	pClientData
	)

Definition at line 114638 of file sqlite3.c.

  {
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(db) || zName==0 ) return SQLITE_MISUSE_BKPT;
 #endif
   return createModule(db, zName, pModule, pAux, 0);
 }

SQLITE_API int SQLITE_STDCALL sqlite3_create_module_v2	(	sqlite3 *	db,
		const char *	zName,
		const sqlite3_module *	p,
		void *	pClientData,
		void()(void )	xDestroy
	)

Definition at line 114653 of file sqlite3.c.

  {
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(db) || zName==0 ) return SQLITE_MISUSE_BKPT;
 #endif
   return createModule(db, zName, pModule, pAux, xDestroy);
 }

SQLITE_API int SQLITE_STDCALL sqlite3_data_count ( sqlite3_stmt * pStmt )

Definition at line 69821 of file sqlite3.c.

References Vdbe::nResColumn, and Vdbe::pResultSet.

                                                                      {
   Vdbe *pVm = (Vdbe *)pStmt;
   if( pVm==0 || pVm->pResultSet==0 ) return 0;
   return pVm->nResColumn;
 }

SQLITE_API int SQLITE_CDECL sqlite3_db_config	(	sqlite3 *	db,
		int	op,
			...
	)

Definition at line 128720 of file sqlite3.c.

References sqlite3::flags, and sqlite3ExpirePreparedStatements().

                                                                        {
   va_list ap;
   int rc;
   va_start(ap, op);
   switch( op ){
     case SQLITE_DBCONFIG_LOOKASIDE: {
       void *pBuf = va_arg(ap, void*); /* IMP: R-26835-10964 */
       int sz = va_arg(ap, int);       /* IMP: R-47871-25994 */
       int cnt = va_arg(ap, int);      /* IMP: R-04460-53386 */
       rc = setupLookaside(db, pBuf, sz, cnt);
       break;
     }
     default: {
       static const struct {
         int op;      /* The opcode */
         u32 mask;    /* Mask of the bit in sqlite3.flags to set/clear */
       } aFlagOp[] = {
         { SQLITE_DBCONFIG_ENABLE_FKEY,    SQLITE_ForeignKeys    },
         { SQLITE_DBCONFIG_ENABLE_TRIGGER, SQLITE_EnableTrigger  },
       };
       unsigned int i;
       rc = SQLITE_ERROR; /* IMP: R-42790-23372 */
       for(i=0; i<ArraySize(aFlagOp); i++){
         if( aFlagOp[i].op==op ){
           int onoff = va_arg(ap, int);
           int *pRes = va_arg(ap, int*);
           int oldFlags = db->flags;
           if( onoff>0 ){
             db->flags |= aFlagOp[i].mask;
           }else if( onoff==0 ){
             db->flags &= ~aFlagOp[i].mask;
           }
           if( oldFlags!=db->flags ){
             sqlite3ExpirePreparedStatements(db);
           }
           if( pRes ){
             *pRes = (db->flags & aFlagOp[i].mask)!=0;
           }
           rc = SQLITE_OK;
           break;
         }
       }
       break;
     }
   }
   va_end(ap);
   return rc;
 }

Here is the call graph for this function:

SQLITE_API const char *SQLITE_STDCALL sqlite3_db_filename	(	sqlite3 *	db,
		const char *	zDbName
	)

Definition at line 131729 of file sqlite3.c.

References sqlite3BtreeGetFilename(), and sqlite3DbNameToBtree().

                                                                                            {
   Btree *pBt;
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(db) ){
     (void)SQLITE_MISUSE_BKPT;
     return 0;
   }
 #endif
   pBt = sqlite3DbNameToBtree(db, zDbName);
   return pBt ? sqlite3BtreeGetFilename(pBt) : 0;
 }

Here is the call graph for this function:

SQLITE_API sqlite3 *SQLITE_STDCALL sqlite3_db_handle ( sqlite3_stmt * pStmt )

Definition at line 70456 of file sqlite3.c.

References Vdbe::db.

                                                                          {
   return pStmt ? ((Vdbe*)pStmt)->db : 0;
 }

SQLITE_API sqlite3_mutex *SQLITE_STDCALL sqlite3_db_mutex ( sqlite3 * db )

Definition at line 128683 of file sqlite3.c.

References sqlite3::mutex.

                                                                       {
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(db) ){
     (void)SQLITE_MISUSE_BKPT;
     return 0;
   }
 #endif
   return db->mutex;
 }

SQLITE_API int SQLITE_STDCALL sqlite3_db_readonly	(	sqlite3 *	db,
		const char *	zDbName
	)

Definition at line 131745 of file sqlite3.c.

References sqlite3BtreeIsReadonly(), and sqlite3DbNameToBtree().

                                                                                    {
   Btree *pBt;
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(db) ){
     (void)SQLITE_MISUSE_BKPT;
     return -1;
   }
 #endif
   pBt = sqlite3DbNameToBtree(db, zDbName);
   return pBt ? sqlite3BtreeIsReadonly(pBt) : -1;
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_db_release_memory ( sqlite3 * db )

Definition at line 128697 of file sqlite3.c.

References sqlite3::aDb, sqlite3::mutex, sqlite3::nDb, Db::pBt, sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3BtreeEnterAll(), sqlite3BtreeLeaveAll(), sqlite3BtreePager(), and sqlite3PagerShrink().

Referenced by sqlite3Pragma().

                                                                     {
   int i;
 
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
 #endif
   sqlite3_mutex_enter(db->mutex);
   sqlite3BtreeEnterAll(db);
   for(i=0; i<db->nDb; i++){
     Btree *pBt = db->aDb[i].pBt;
     if( pBt ){
       Pager *pPager = sqlite3BtreePager(pBt);
       sqlite3PagerShrink(pPager);
     }
   }
   sqlite3BtreeLeaveAll(db);
   sqlite3_mutex_leave(db->mutex);
   return SQLITE_OK;
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_db_status	(	sqlite3 *	db,
		int	op,
		int *	pCur,
		int *	pHiwtr,
		int	resetFlg
	)

Definition at line 15151 of file sqlite3.c.

References sqlite3::aDb, Lookaside::anStat, Hash::count, Schema::fkeyHash, Schema::idxHash, sqlite3::lookaside, Sqlite3Config::m, sqlite3::mutex, Lookaside::mxOut, sqlite3::nDb, sqlite3::nDeferredCons, sqlite3::nDeferredImmCons, Lookaside::nOut, Db::pBt, sqlite3::pnBytesFreed, Vdbe::pNext, Db::pSchema, sqlite3::pVdbe, sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3BtreeEnterAll(), sqlite3BtreeLeaveAll(), sqlite3BtreePager(), sqlite3DbFree(), sqlite3DeleteTable(), sqlite3DeleteTrigger(), sqlite3MallocSize(), sqlite3PagerCacheStat(), sqlite3PagerMemUsed(), sqlite3VdbeClearObject(), Schema::tblHash, Schema::trigHash, and sqlite3_mem_methods::xRoundup.

  {
   int rc = SQLITE_OK;   /* Return code */
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(db) || pCurrent==0|| pHighwater==0 ){
     return SQLITE_MISUSE_BKPT;
   }
 #endif
   sqlite3_mutex_enter(db->mutex);
   switch( op ){
     case SQLITE_DBSTATUS_LOOKASIDE_USED: {
       *pCurrent = db->lookaside.nOut;
       *pHighwater = db->lookaside.mxOut;
       if( resetFlag ){
         db->lookaside.mxOut = db->lookaside.nOut;
       }
       break;
     }
 
     case SQLITE_DBSTATUS_LOOKASIDE_HIT:
     case SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE:
     case SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL: {
       testcase( op==SQLITE_DBSTATUS_LOOKASIDE_HIT );
       testcase( op==SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE );
       testcase( op==SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL );
       assert( (op-SQLITE_DBSTATUS_LOOKASIDE_HIT)>=0 );
       assert( (op-SQLITE_DBSTATUS_LOOKASIDE_HIT)<3 );
       *pCurrent = 0;
       *pHighwater = db->lookaside.anStat[op - SQLITE_DBSTATUS_LOOKASIDE_HIT];
       if( resetFlag ){
         db->lookaside.anStat[op - SQLITE_DBSTATUS_LOOKASIDE_HIT] = 0;
       }
       break;
     }
 
     /* 
     ** Return an approximation for the amount of memory currently used
     ** by all pagers associated with the given database connection.  The
     ** highwater mark is meaningless and is returned as zero.
     */
     case SQLITE_DBSTATUS_CACHE_USED: {
       int totalUsed = 0;
       int i;
       sqlite3BtreeEnterAll(db);
       for(i=0; i<db->nDb; i++){
         Btree *pBt = db->aDb[i].pBt;
         if( pBt ){
           Pager *pPager = sqlite3BtreePager(pBt);
           totalUsed += sqlite3PagerMemUsed(pPager);
         }
       }
       sqlite3BtreeLeaveAll(db);
       *pCurrent = totalUsed;
       *pHighwater = 0;
       break;
     }
 
     /*
     ** *pCurrent gets an accurate estimate of the amount of memory used
     ** to store the schema for all databases (main, temp, and any ATTACHed
     ** databases.  *pHighwater is set to zero.
     */
     case SQLITE_DBSTATUS_SCHEMA_USED: {
       int i;                      /* Used to iterate through schemas */
       int nByte = 0;              /* Used to accumulate return value */
 
       sqlite3BtreeEnterAll(db);
       db->pnBytesFreed = &nByte;
       for(i=0; i<db->nDb; i++){
         Schema *pSchema = db->aDb[i].pSchema;
         if( ALWAYS(pSchema!=0) ){
           HashElem *p;
 
           nByte += sqlite3GlobalConfig.m.xRoundup(sizeof(HashElem)) * (
               pSchema->tblHash.count 
             + pSchema->trigHash.count
             + pSchema->idxHash.count
             + pSchema->fkeyHash.count
           );
           nByte += sqlite3MallocSize(pSchema->tblHash.ht);
           nByte += sqlite3MallocSize(pSchema->trigHash.ht);
           nByte += sqlite3MallocSize(pSchema->idxHash.ht);
           nByte += sqlite3MallocSize(pSchema->fkeyHash.ht);
 
           for(p=sqliteHashFirst(&pSchema->trigHash); p; p=sqliteHashNext(p)){
             sqlite3DeleteTrigger(db, (Trigger*)sqliteHashData(p));
           }
           for(p=sqliteHashFirst(&pSchema->tblHash); p; p=sqliteHashNext(p)){
             sqlite3DeleteTable(db, (Table *)sqliteHashData(p));
           }
         }
       }
       db->pnBytesFreed = 0;
       sqlite3BtreeLeaveAll(db);
 
       *pHighwater = 0;
       *pCurrent = nByte;
       break;
     }
 
     /*
     ** *pCurrent gets an accurate estimate of the amount of memory used
     ** to store all prepared statements.
     ** *pHighwater is set to zero.
     */
     case SQLITE_DBSTATUS_STMT_USED: {
       struct Vdbe *pVdbe;         /* Used to iterate through VMs */
       int nByte = 0;              /* Used to accumulate return value */
 
       db->pnBytesFreed = &nByte;
       for(pVdbe=db->pVdbe; pVdbe; pVdbe=pVdbe->pNext){
         sqlite3VdbeClearObject(db, pVdbe);
         sqlite3DbFree(db, pVdbe);
       }
       db->pnBytesFreed = 0;
 
       *pHighwater = 0;  /* IMP: R-64479-57858 */
       *pCurrent = nByte;
 
       break;
     }
 
     /*
     ** Set *pCurrent to the total cache hits or misses encountered by all
     ** pagers the database handle is connected to. *pHighwater is always set 
     ** to zero.
     */
     case SQLITE_DBSTATUS_CACHE_HIT:
     case SQLITE_DBSTATUS_CACHE_MISS:
     case SQLITE_DBSTATUS_CACHE_WRITE:{
       int i;
       int nRet = 0;
       assert( SQLITE_DBSTATUS_CACHE_MISS==SQLITE_DBSTATUS_CACHE_HIT+1 );
       assert( SQLITE_DBSTATUS_CACHE_WRITE==SQLITE_DBSTATUS_CACHE_HIT+2 );
 
       for(i=0; i<db->nDb; i++){
         if( db->aDb[i].pBt ){
           Pager *pPager = sqlite3BtreePager(db->aDb[i].pBt);
           sqlite3PagerCacheStat(pPager, op, resetFlag, &nRet);
         }
       }
       *pHighwater = 0; /* IMP: R-42420-56072 */
                        /* IMP: R-54100-20147 */
                        /* IMP: R-29431-39229 */
       *pCurrent = nRet;
       break;
     }
 
     /* Set *pCurrent to non-zero if there are unresolved deferred foreign
     ** key constraints.  Set *pCurrent to zero if all foreign key constraints
     ** have been satisfied.  The *pHighwater is always set to zero.
     */
     case SQLITE_DBSTATUS_DEFERRED_FKS: {
       *pHighwater = 0;  /* IMP: R-11967-56545 */
       *pCurrent = db->nDeferredImmCons>0 || db->nDeferredCons>0;
       break;
     }
 
     default: {
       rc = SQLITE_ERROR;
     }
   }
   sqlite3_mutex_leave(db->mutex);
   return rc;
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_declare_vtab	(	sqlite3 *	db,
		const char *	zSQL
	)

Definition at line 115289 of file sqlite3.c.

References Table::aCol, VtabCtx::bDeclared, Parse::db, Parse::declareVtab, sqlite3::mallocFailed, sqlite3::mutex, Table::nCol, Parse::nQueryLoop, Parse::pNewTable, Table::pSelect, VtabCtx::pTab, Parse::pVdbe, sqlite3::pVtabCtx, sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3ApiExit(), sqlite3DbFree(), sqlite3DeleteTable(), sqlite3Error(), sqlite3ErrorWithMsg(), sqlite3ParserReset(), sqlite3RunParser(), sqlite3VdbeFinalize(), and Table::tabFlags.

                                                                                          {
   VtabCtx *pCtx;
   Parse *pParse;
   int rc = SQLITE_OK;
   Table *pTab;
   char *zErr = 0;
 
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(db) || zCreateTable==0 ){
     return SQLITE_MISUSE_BKPT;
   }
 #endif
   sqlite3_mutex_enter(db->mutex);
   pCtx = db->pVtabCtx;
   if( !pCtx || pCtx->bDeclared ){
     sqlite3Error(db, SQLITE_MISUSE);
     sqlite3_mutex_leave(db->mutex);
     return SQLITE_MISUSE_BKPT;
   }
   pTab = pCtx->pTab;
   assert( (pTab->tabFlags & TF_Virtual)!=0 );
 
   pParse = sqlite3StackAllocZero(db, sizeof(*pParse));
   if( pParse==0 ){
     rc = SQLITE_NOMEM;
   }else{
     pParse->declareVtab = 1;
     pParse->db = db;
     pParse->nQueryLoop = 1;
   
     if( SQLITE_OK==sqlite3RunParser(pParse, zCreateTable, &zErr) 
      && pParse->pNewTable
      && !db->mallocFailed
      && !pParse->pNewTable->pSelect
      && (pParse->pNewTable->tabFlags & TF_Virtual)==0
     ){
       if( !pTab->aCol ){
         pTab->aCol = pParse->pNewTable->aCol;
         pTab->nCol = pParse->pNewTable->nCol;
         pParse->pNewTable->nCol = 0;
         pParse->pNewTable->aCol = 0;
       }
       pCtx->bDeclared = 1;
     }else{
       sqlite3ErrorWithMsg(db, SQLITE_ERROR, (zErr ? "%s" : 0), zErr);
       sqlite3DbFree(db, zErr);
       rc = SQLITE_ERROR;
     }
     pParse->declareVtab = 0;
   
     if( pParse->pVdbe ){
       sqlite3VdbeFinalize(pParse->pVdbe);
     }
     sqlite3DeleteTable(db, pParse->pNewTable);
     sqlite3ParserReset(pParse);
     sqlite3StackFree(db, pParse);
   }
 
   assert( (rc&0xff)==rc );
   rc = sqlite3ApiExit(db, rc);
   sqlite3_mutex_leave(db->mutex);
   return rc;
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_enable_load_extension	(	sqlite3 *	db,
		int	onoff
	)

Definition at line 102954 of file sqlite3.c.

References sqlite3::flags, sqlite3::mutex, sqlite3_mutex_enter(), and sqlite3_mutex_leave().

                                                                                    {
   sqlite3_mutex_enter(db->mutex);
   if( onoff ){
     db->flags |= SQLITE_LoadExtension;
   }else{
     db->flags &= ~SQLITE_LoadExtension;
   }
   sqlite3_mutex_leave(db->mutex);
   return SQLITE_OK;
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_enable_shared_cache ( int enable )

Definition at line 53171 of file sqlite3.c.

References Sqlite3Config::sharedCacheEnabled.

                                                                      {
   sqlite3GlobalConfig.sharedCacheEnabled = enable;
   return SQLITE_OK;
 }

SQLITE_API int SQLITE_STDCALL sqlite3_errcode ( sqlite3 * db )

Definition at line 130151 of file sqlite3.c.

References sqlite3::errCode, sqlite3::errMask, sqlite3::mallocFailed, and sqlite3SafetyCheckSickOrOk().

                                                           {
   if( db && !sqlite3SafetyCheckSickOrOk(db) ){
     return SQLITE_MISUSE_BKPT;
   }
   if( !db || db->mallocFailed ){
     return SQLITE_NOMEM;
   }
   return db->errCode & db->errMask;
 }

Here is the call graph for this function:

SQLITE_API const char *SQLITE_STDCALL sqlite3_errmsg ( sqlite3 * db )

Definition at line 130078 of file sqlite3.c.

References sqlite3::errCode, sqlite3::mallocFailed, sqlite3::mutex, sqlite3::pErr, sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3_value_text(), sqlite3ErrStr(), and sqlite3SafetyCheckSickOrOk().

Referenced by sqlite3_exec(), and sqlite3InitCallback().

                                                                  {
   const char *z;
   if( !db ){
     return sqlite3ErrStr(SQLITE_NOMEM);
   }
   if( !sqlite3SafetyCheckSickOrOk(db) ){
     return sqlite3ErrStr(SQLITE_MISUSE_BKPT);
   }
   sqlite3_mutex_enter(db->mutex);
   if( db->mallocFailed ){
     z = sqlite3ErrStr(SQLITE_NOMEM);
   }else{
     testcase( db->pErr==0 );
     z = (char*)sqlite3_value_text(db->pErr);
     assert( !db->mallocFailed );
     if( z==0 ){
       z = sqlite3ErrStr(db->errCode);
     }
   }
   sqlite3_mutex_leave(db->mutex);
   return z;
 }

Here is the call graph for this function:

SQLITE_API const void *SQLITE_STDCALL sqlite3_errmsg16 ( sqlite3 * db )

Definition at line 130106 of file sqlite3.c.

References sqlite3::errCode, sqlite3::mallocFailed, sqlite3::mutex, sqlite3::pErr, sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3_value_text16(), sqlite3ErrorWithMsg(), sqlite3ErrStr(), and sqlite3SafetyCheckSickOrOk().

                                                                    {
   static const u16 outOfMem[] = {
     'o', 'u', 't', ' ', 'o', 'f', ' ', 'm', 'e', 'm', 'o', 'r', 'y', 0
   };
   static const u16 misuse[] = {
     'l', 'i', 'b', 'r', 'a', 'r', 'y', ' ', 
     'r', 'o', 'u', 't', 'i', 'n', 'e', ' ', 
     'c', 'a', 'l', 'l', 'e', 'd', ' ', 
     'o', 'u', 't', ' ', 
     'o', 'f', ' ', 
     's', 'e', 'q', 'u', 'e', 'n', 'c', 'e', 0
   };
 
   const void *z;
   if( !db ){
     return (void *)outOfMem;
   }
   if( !sqlite3SafetyCheckSickOrOk(db) ){
     return (void *)misuse;
   }
   sqlite3_mutex_enter(db->mutex);
   if( db->mallocFailed ){
     z = (void *)outOfMem;
   }else{
     z = sqlite3_value_text16(db->pErr);
     if( z==0 ){
       sqlite3ErrorWithMsg(db, db->errCode, sqlite3ErrStr(db->errCode));
       z = sqlite3_value_text16(db->pErr);
     }
     /* A malloc() may have failed within the call to sqlite3_value_text16()
     ** above. If this is the case, then the db->mallocFailed flag needs to
     ** be cleared before returning. Do this directly, instead of via
     ** sqlite3ApiExit(), to avoid setting the database handle error message.
     */
     db->mallocFailed = 0;
   }
   sqlite3_mutex_leave(db->mutex);
   return z;
 }

Here is the call graph for this function:

SQLITE_API const char *SQLITE_STDCALL sqlite3_errstr ( int rc )

Definition at line 130175 of file sqlite3.c.

References sqlite3ErrStr().

                                                             {
   return sqlite3ErrStr(rc);
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_exec	(	sqlite3 *	db,
		const char *	sql,
		int()(void , int, char , char )	callback,
		void *	pArg,
		char **	errmsg
	)

Definition at line 101728 of file sqlite3.c.

References sqlite3::flags, sqlite3::mallocFailed, sqlite3::mutex, sqlite3_column_count(), sqlite3_column_name(), sqlite3_column_text(), sqlite3_column_type(), sqlite3_errmsg(), sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3_prepare_v2(), sqlite3_step(), sqlite3ApiExit(), sqlite3DbFree(), sqlite3Error(), sqlite3SafetyCheckOk(), sqlite3Strlen30(), and sqlite3VdbeFinalize().

Referenced by sqlite3_get_table(), sqlite3AnalysisLoad(), and sqlite3VdbeExec().

  {
   int rc = SQLITE_OK;         /* Return code */
   const char *zLeftover;      /* Tail of unprocessed SQL */
   sqlite3_stmt *pStmt = 0;    /* The current SQL statement */
   char **azCols = 0;          /* Names of result columns */
   int callbackIsInit;         /* True if callback data is initialized */
 
   if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
   if( zSql==0 ) zSql = "";
 
   sqlite3_mutex_enter(db->mutex);
   sqlite3Error(db, SQLITE_OK);
   while( rc==SQLITE_OK && zSql[0] ){
     int nCol;
     char **azVals = 0;
 
     pStmt = 0;
     rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, &zLeftover);
     assert( rc==SQLITE_OK || pStmt==0 );
     if( rc!=SQLITE_OK ){
       continue;
     }
     if( !pStmt ){
       /* this happens for a comment or white-space */
       zSql = zLeftover;
       continue;
     }
 
     callbackIsInit = 0;
     nCol = sqlite3_column_count(pStmt);
 
     while( 1 ){
       int i;
       rc = sqlite3_step(pStmt);
 
       /* Invoke the callback function if required */
       if( xCallback && (SQLITE_ROW==rc || 
           (SQLITE_DONE==rc && !callbackIsInit
                            && db->flags&SQLITE_NullCallback)) ){
         if( !callbackIsInit ){
           azCols = sqlite3DbMallocZero(db, 2*nCol*sizeof(const char*) + 1);
           if( azCols==0 ){
             goto exec_out;
           }
           for(i=0; i<nCol; i++){
             azCols[i] = (char *)sqlite3_column_name(pStmt, i);
             /* sqlite3VdbeSetColName() installs column names as UTF8
             ** strings so there is no way for sqlite3_column_name() to fail. */
             assert( azCols[i]!=0 );
           }
           callbackIsInit = 1;
         }
         if( rc==SQLITE_ROW ){
           azVals = &azCols[nCol];
           for(i=0; i<nCol; i++){
             azVals[i] = (char *)sqlite3_column_text(pStmt, i);
             if( !azVals[i] && sqlite3_column_type(pStmt, i)!=SQLITE_NULL ){
               db->mallocFailed = 1;
               goto exec_out;
             }
           }
         }
         if( xCallback(pArg, nCol, azVals, azCols) ){
           /* EVIDENCE-OF: R-38229-40159 If the callback function to
           ** sqlite3_exec() returns non-zero, then sqlite3_exec() will
           ** return SQLITE_ABORT. */
           rc = SQLITE_ABORT;
           sqlite3VdbeFinalize((Vdbe *)pStmt);
           pStmt = 0;
           sqlite3Error(db, SQLITE_ABORT);
           goto exec_out;
         }
       }
 
       if( rc!=SQLITE_ROW ){
         rc = sqlite3VdbeFinalize((Vdbe *)pStmt);
         pStmt = 0;
         zSql = zLeftover;
         while( sqlite3Isspace(zSql[0]) ) zSql++;
         break;
       }
     }
 
     sqlite3DbFree(db, azCols);
     azCols = 0;
   }
 
 exec_out:
   if( pStmt ) sqlite3VdbeFinalize((Vdbe *)pStmt);
   sqlite3DbFree(db, azCols);
 
   rc = sqlite3ApiExit(db, rc);
   if( rc!=SQLITE_OK && pzErrMsg ){
     int nErrMsg = 1 + sqlite3Strlen30(sqlite3_errmsg(db));
     *pzErrMsg = sqlite3Malloc(nErrMsg);
     if( *pzErrMsg ){
       memcpy(*pzErrMsg, sqlite3_errmsg(db), nErrMsg);
     }else{
       rc = SQLITE_NOMEM;
       sqlite3Error(db, SQLITE_NOMEM);
     }
   }else if( pzErrMsg ){
     *pzErrMsg = 0;
   }
 
   assert( (rc&db->errMask)==rc );
   sqlite3_mutex_leave(db->mutex);
   return rc;
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_expired ( sqlite3_stmt * pStmt )

Definition at line 69034 of file sqlite3.c.

References Vdbe::expired.

                                                                   {
   Vdbe *p = (Vdbe*)pStmt;
   return p==0 || p->expired;
 }

SQLITE_API int SQLITE_STDCALL sqlite3_extended_errcode ( sqlite3 * db )

Definition at line 130160 of file sqlite3.c.

References sqlite3::errCode, sqlite3::mallocFailed, and sqlite3SafetyCheckSickOrOk().

                                                                    {
   if( db && !sqlite3SafetyCheckSickOrOk(db) ){
     return SQLITE_MISUSE_BKPT;
   }
   if( !db || db->mallocFailed ){
     return SQLITE_NOMEM;
   }
   return db->errCode;
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_extended_result_codes	(	sqlite3 *	db,
		int	onoff
	)

Definition at line 131283 of file sqlite3.c.

References sqlite3::errMask, sqlite3::mutex, sqlite3_mutex_enter(), and sqlite3_mutex_leave().

                                                                                    {
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
 #endif
   sqlite3_mutex_enter(db->mutex);
   db->errMask = onoff ? 0xffffffff : 0xff;
   sqlite3_mutex_leave(db->mutex);
   return SQLITE_OK;
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_file_control	(	sqlite3 *	db,
		const char *	zDbName,
		int	op,
		void *	pArg
	)

Definition at line 131296 of file sqlite3.c.

References sqlite3::mutex, sqlite3_file::pMethods, sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3BtreeEnter(), sqlite3BtreeLeave(), sqlite3BtreePager(), sqlite3DbNameToBtree(), sqlite3OsFileControl(), and sqlite3PagerFile().

Referenced by sqlite3Pragma().

                                                                                                         {
   int rc = SQLITE_ERROR;
   Btree *pBtree;
 
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
 #endif
   sqlite3_mutex_enter(db->mutex);
   pBtree = sqlite3DbNameToBtree(db, zDbName);
   if( pBtree ){
     Pager *pPager;
     sqlite3_file *fd;
     sqlite3BtreeEnter(pBtree);
     pPager = sqlite3BtreePager(pBtree);
     assert( pPager!=0 );
     fd = sqlite3PagerFile(pPager);
     assert( fd!=0 );
     if( op==SQLITE_FCNTL_FILE_POINTER ){
       *(sqlite3_file**)pArg = fd;
       rc = SQLITE_OK;
     }else if( fd->pMethods ){
       rc = sqlite3OsFileControl(fd, op, pArg);
     }else{
       rc = SQLITE_NOTFOUND;
     }
     sqlite3BtreeLeave(pBtree);
   }
   sqlite3_mutex_leave(db->mutex);
   return rc;
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_finalize ( sqlite3_stmt * pStmt )

Definition at line 69071 of file sqlite3.c.

References Vdbe::db, sqlite3::mutex, sqlite3_mutex_enter(), sqlite3ApiExit(), sqlite3LeaveMutexAndCloseZombie(), and sqlite3VdbeFinalize().

Referenced by sqlite3_blob_close(), and sqlite3InitCallback().

                                                                    {
   int rc;
   if( pStmt==0 ){
     /* IMPLEMENTATION-OF: R-57228-12904 Invoking sqlite3_finalize() on a NULL
     ** pointer is a harmless no-op. */
     rc = SQLITE_OK;
   }else{
     Vdbe *v = (Vdbe*)pStmt;
     sqlite3 *db = v->db;
     if( vdbeSafety(v) ) return SQLITE_MISUSE_BKPT;
     sqlite3_mutex_enter(db->mutex);
     rc = sqlite3VdbeFinalize(v);
     rc = sqlite3ApiExit(db, rc);
     sqlite3LeaveMutexAndCloseZombie(db);
   }
   return rc;
 }

Here is the call graph for this function:

SQLITE_API void SQLITE_STDCALL sqlite3_free ( void * p )

Definition at line 21010 of file sqlite3.c.

References Sqlite3Config::bMemstat, Sqlite3Config::m, sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3MallocSize(), sqlite3StatusDown(), and sqlite3_mem_methods::xFree.

Referenced by sqlite3_backup_finish(), sqlite3_backup_init(), sqlite3_free_table(), sqlite3_get_table(), sqlite3_reset_auto_extension(), sqlite3AutoLoadExtensions(), sqlite3BitvecBuiltinTest(), sqlite3BitvecDestroy(), sqlite3BtreeClearCursor(), sqlite3BtreeClose(), sqlite3BtreeCloseCursor(), sqlite3BtreeIntegrityCheck(), sqlite3BtreeMovetoUnpacked(), sqlite3BtreeOpen(), sqlite3DbFree(), sqlite3HashClear(), sqlite3InvalidFunction(), sqlite3LeaveMutexAndCloseZombie(), sqlite3OsCloseFree(), sqlite3OsInit(), sqlite3OsOpenMalloc(), sqlite3PagerClose(), sqlite3PagerOpen(), sqlite3ParseUri(), sqlite3Pragma(), sqlite3Realloc(), sqlite3RunParser(), sqlite3StrAccumReset(), sqlite3ThreadJoin(), sqlite3VdbeExec(), sqlite3VdbeSorterClose(), sqlite3VtabImportErrmsg(), sqlite3VXPrintf(), sqlite3WalClose(), and sqlite3WalOpen().

                                                     {
   if( p==0 ) return;  /* IMP: R-49053-54554 */
   assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) );
   assert( sqlite3MemdebugNoType(p, (u8)~MEMTYPE_HEAP) );
   if( sqlite3GlobalConfig.bMemstat ){
     sqlite3_mutex_enter(mem0.mutex);
     sqlite3StatusDown(SQLITE_STATUS_MEMORY_USED, sqlite3MallocSize(p));
     sqlite3StatusDown(SQLITE_STATUS_MALLOC_COUNT, 1);
     sqlite3GlobalConfig.m.xFree(p);
     sqlite3_mutex_leave(mem0.mutex);
   }else{
     sqlite3GlobalConfig.m.xFree(p);
   }
 }

Here is the call graph for this function:

SQLITE_API void SQLITE_STDCALL sqlite3_free_table ( char ** result )

Definition at line 112272 of file sqlite3.c.

References sqlite3_free().

Referenced by sqlite3_get_table().

  {
   if( azResult ){
     int i, n;
     azResult--;
     assert( azResult!=0 );
     n = SQLITE_PTR_TO_INT(azResult[0]);
     for(i=1; i<n; i++){ if( azResult[i] ) sqlite3_free(azResult[i]); }
     sqlite3_free(azResult);
   }
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_get_autocommit ( sqlite3 * db )

Definition at line 131089 of file sqlite3.c.

References sqlite3::autoCommit.

                                                                  {
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(db) ){
     (void)SQLITE_MISUSE_BKPT;
     return 0;
   }
 #endif
   return db->autoCommit;
 }

SQLITE_API void *SQLITE_STDCALL sqlite3_get_auxdata	(	sqlite3_context *	pCtx,
		int	N
	)

Definition at line 69727 of file sqlite3.c.

References AuxData::iArg, AuxData::iOp, sqlite3_context::iOp, AuxData::pAux, Vdbe::pAuxData, AuxData::pNext, and sqlite3_context::pVdbe.

                                                                                     {
   AuxData *pAuxData;
 
   assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
 #if SQLITE_ENABLE_STAT3_OR_STAT4
   if( pCtx->pVdbe==0 ) return 0;
 #else
   assert( pCtx->pVdbe!=0 );
 #endif
   for(pAuxData=pCtx->pVdbe->pAuxData; pAuxData; pAuxData=pAuxData->pNext){
     if( pAuxData->iOp==pCtx->iOp && pAuxData->iArg==iArg ) break;
   }
 
   return (pAuxData ? pAuxData->pAux : 0);
 }

SQLITE_API int SQLITE_STDCALL sqlite3_get_table	(	sqlite3 *	db,
		const char *	zSql,
		char ***	pazResult,
		int *	pnRow,
		int *	pnColumn,
		char **	pzErrmsg
	)

Definition at line 112203 of file sqlite3.c.

References TabResult::azResult, sqlite3::errCode, TabResult::nAlloc, TabResult::nColumn, TabResult::nData, TabResult::nRow, TabResult::rc, sqlite3_exec(), sqlite3_free(), sqlite3_free_table(), sqlite3_mprintf(), and TabResult::zErrMsg.

  {
   int rc;
   TabResult res;
 
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(db) || pazResult==0 ) return SQLITE_MISUSE_BKPT;
 #endif
   *pazResult = 0;
   if( pnColumn ) *pnColumn = 0;
   if( pnRow ) *pnRow = 0;
   if( pzErrMsg ) *pzErrMsg = 0;
   res.zErrMsg = 0;
   res.nRow = 0;
   res.nColumn = 0;
   res.nData = 1;
   res.nAlloc = 20;
   res.rc = SQLITE_OK;
   res.azResult = sqlite3_malloc(sizeof(char*)*res.nAlloc );
   if( res.azResult==0 ){
      db->errCode = SQLITE_NOMEM;
      return SQLITE_NOMEM;
   }
   res.azResult[0] = 0;
   rc = sqlite3_exec(db, zSql, sqlite3_get_table_cb, &res, pzErrMsg);
   assert( sizeof(res.azResult[0])>= sizeof(res.nData) );
   res.azResult[0] = SQLITE_INT_TO_PTR(res.nData);
   if( (rc&0xff)==SQLITE_ABORT ){
     sqlite3_free_table(&res.azResult[1]);
     if( res.zErrMsg ){
       if( pzErrMsg ){
         sqlite3_free(*pzErrMsg);
         *pzErrMsg = sqlite3_mprintf("%s",res.zErrMsg);
       }
       sqlite3_free(res.zErrMsg);
     }
     db->errCode = res.rc;  /* Assume 32-bit assignment is atomic */
     return res.rc;
   }
   sqlite3_free(res.zErrMsg);
   if( rc!=SQLITE_OK ){
     sqlite3_free_table(&res.azResult[1]);
     return rc;
   }
   if( res.nAlloc>res.nData ){
     char **azNew;
     azNew = sqlite3_realloc( res.azResult, sizeof(char*)*res.nData );
     if( azNew==0 ){
       sqlite3_free_table(&res.azResult[1]);
       db->errCode = SQLITE_NOMEM;
       return SQLITE_NOMEM;
     }
     res.azResult = azNew;
   }
   *pazResult = &res.azResult[1];
   if( pnColumn ) *pnColumn = res.nColumn;
   if( pnRow ) *pnRow = res.nRow;
   return rc;
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_global_recover ( void )

Definition at line 131078 of file sqlite3.c.

                                                           {
   return SQLITE_OK;
 }

SQLITE_API int SQLITE_STDCALL sqlite3_initialize ( void )

Definition at line 128111 of file sqlite3.c.

References Sqlite3Config::bCoreMutex, Sqlite3Config::inProgress, Sqlite3Config::isInit, Sqlite3Config::isMallocInit, Sqlite3Config::isMutexInit, Sqlite3Config::isPCacheInit, Sqlite3Config::nPage, Sqlite3Config::nRefInitMutex, Sqlite3Config::pInitMutex, Sqlite3Config::pPage, sqlite3_mutex_enter(), sqlite3_mutex_free(), sqlite3_mutex_leave(), sqlite3GlobalFunctions, sqlite3MallocInit(), sqlite3MutexAlloc(), sqlite3MutexInit(), sqlite3OsInit(), sqlite3PCacheBufferSetup(), sqlite3PcacheInitialize(), sqlite3RegisterGlobalFunctions(), and Sqlite3Config::szPage.

Referenced by sqlite3_auto_extension(), sqlite3_complete16(), sqlite3_malloc(), sqlite3_malloc64(), sqlite3_mprintf(), sqlite3_mutex_alloc(), sqlite3_open16(), sqlite3_randomness(), sqlite3_realloc(), sqlite3_realloc64(), sqlite3_reset_auto_extension(), sqlite3_soft_heap_limit64(), sqlite3_vfs_find(), sqlite3_vfs_register(), and sqlite3_vmprintf().

                                                       {
   MUTEX_LOGIC( sqlite3_mutex *pMaster; )       /* The main static mutex */
   int rc;                                      /* Result code */
 #ifdef SQLITE_EXTRA_INIT
   int bRunExtraInit = 0;                       /* Extra initialization needed */
 #endif
 
 #ifdef SQLITE_OMIT_WSD
   rc = sqlite3_wsd_init(4096, 24);
   if( rc!=SQLITE_OK ){
     return rc;
   }
 #endif
 
   /* If the following assert() fails on some obscure processor/compiler
   ** combination, the work-around is to set the correct pointer
   ** size at compile-time using -DSQLITE_PTRSIZE=n compile-time option */
   assert( SQLITE_PTRSIZE==sizeof(char*) );
 
   /* If SQLite is already completely initialized, then this call
   ** to sqlite3_initialize() should be a no-op.  But the initialization
   ** must be complete.  So isInit must not be set until the very end
   ** of this routine.
   */
   if( sqlite3GlobalConfig.isInit ) return SQLITE_OK;
 
   /* Make sure the mutex subsystem is initialized.  If unable to 
   ** initialize the mutex subsystem, return early with the error.
   ** If the system is so sick that we are unable to allocate a mutex,
   ** there is not much SQLite is going to be able to do.
   **
   ** The mutex subsystem must take care of serializing its own
   ** initialization.
   */
   rc = sqlite3MutexInit();
   if( rc ) return rc;
 
   /* Initialize the malloc() system and the recursive pInitMutex mutex.
   ** This operation is protected by the STATIC_MASTER mutex.  Note that
   ** MutexAlloc() is called for a static mutex prior to initializing the
   ** malloc subsystem - this implies that the allocation of a static
   ** mutex must not require support from the malloc subsystem.
   */
   MUTEX_LOGIC( pMaster = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER); )
   sqlite3_mutex_enter(pMaster);
   sqlite3GlobalConfig.isMutexInit = 1;
   if( !sqlite3GlobalConfig.isMallocInit ){
     rc = sqlite3MallocInit();
   }
   if( rc==SQLITE_OK ){
     sqlite3GlobalConfig.isMallocInit = 1;
     if( !sqlite3GlobalConfig.pInitMutex ){
       sqlite3GlobalConfig.pInitMutex =
            sqlite3MutexAlloc(SQLITE_MUTEX_RECURSIVE);
       if( sqlite3GlobalConfig.bCoreMutex && !sqlite3GlobalConfig.pInitMutex ){
         rc = SQLITE_NOMEM;
       }
     }
   }
   if( rc==SQLITE_OK ){
     sqlite3GlobalConfig.nRefInitMutex++;
   }
   sqlite3_mutex_leave(pMaster);
 
   /* If rc is not SQLITE_OK at this point, then either the malloc
   ** subsystem could not be initialized or the system failed to allocate
   ** the pInitMutex mutex. Return an error in either case.  */
   if( rc!=SQLITE_OK ){
     return rc;
   }
 
   /* Do the rest of the initialization under the recursive mutex so
   ** that we will be able to handle recursive calls into
   ** sqlite3_initialize().  The recursive calls normally come through
   ** sqlite3_os_init() when it invokes sqlite3_vfs_register(), but other
   ** recursive calls might also be possible.
   **
   ** IMPLEMENTATION-OF: R-00140-37445 SQLite automatically serializes calls
   ** to the xInit method, so the xInit method need not be threadsafe.
   **
   ** The following mutex is what serializes access to the appdef pcache xInit
   ** methods.  The sqlite3_pcache_methods.xInit() all is embedded in the
   ** call to sqlite3PcacheInitialize().
   */
   sqlite3_mutex_enter(sqlite3GlobalConfig.pInitMutex);
   if( sqlite3GlobalConfig.isInit==0 && sqlite3GlobalConfig.inProgress==0 ){
     FuncDefHash *pHash = &GLOBAL(FuncDefHash, sqlite3GlobalFunctions);
     sqlite3GlobalConfig.inProgress = 1;
     memset(pHash, 0, sizeof(sqlite3GlobalFunctions));
     sqlite3RegisterGlobalFunctions();
     if( sqlite3GlobalConfig.isPCacheInit==0 ){
       rc = sqlite3PcacheInitialize();
     }
     if( rc==SQLITE_OK ){
       sqlite3GlobalConfig.isPCacheInit = 1;
       rc = sqlite3OsInit();
     }
     if( rc==SQLITE_OK ){
       sqlite3PCacheBufferSetup( sqlite3GlobalConfig.pPage, 
           sqlite3GlobalConfig.szPage, sqlite3GlobalConfig.nPage);
       sqlite3GlobalConfig.isInit = 1;
 #ifdef SQLITE_EXTRA_INIT
       bRunExtraInit = 1;
 #endif
     }
     sqlite3GlobalConfig.inProgress = 0;
   }
   sqlite3_mutex_leave(sqlite3GlobalConfig.pInitMutex);
 
   /* Go back under the static mutex and clean up the recursive
   ** mutex to prevent a resource leak.
   */
   sqlite3_mutex_enter(pMaster);
   sqlite3GlobalConfig.nRefInitMutex--;
   if( sqlite3GlobalConfig.nRefInitMutex<=0 ){
     assert( sqlite3GlobalConfig.nRefInitMutex==0 );
     sqlite3_mutex_free(sqlite3GlobalConfig.pInitMutex);
     sqlite3GlobalConfig.pInitMutex = 0;
   }
   sqlite3_mutex_leave(pMaster);
 
   /* The following is just a sanity check to make sure SQLite has
   ** been compiled correctly.  It is important to run this code, but
   ** we don't want to run it too often and soak up CPU cycles for no
   ** reason.  So we run it once during initialization.
   */
 #ifndef NDEBUG
 #ifndef SQLITE_OMIT_FLOATING_POINT
   /* This section of code's only "output" is via assert() statements. */
   if ( rc==SQLITE_OK ){
     u64 x = (((u64)1)<<63)-1;
     double y;
     assert(sizeof(x)==8);
     assert(sizeof(x)==sizeof(y));
     memcpy(&y, &x, 8);
     assert( sqlite3IsNaN(y) );
   }
 #endif
 #endif
 
   /* Do extra initialization steps requested by the SQLITE_EXTRA_INIT
   ** compile-time option.
   */
 #ifdef SQLITE_EXTRA_INIT
   if( bRunExtraInit ){
     int SQLITE_EXTRA_INIT(const char*);
     rc = SQLITE_EXTRA_INIT(0);
   }
 #endif
 
   return rc;
 }

Here is the call graph for this function:

SQLITE_API void SQLITE_STDCALL sqlite3_interrupt ( sqlite3 * db )

Definition at line 129485 of file sqlite3.c.

                                                              {
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(db) ){
     (void)SQLITE_MISUSE_BKPT;
     return;
   }
 #endif
   db->u1.isInterrupted = 1;
 }

SQLITE_API sqlite_int64 SQLITE_STDCALL sqlite3_last_insert_rowid ( sqlite3 * db )

Definition at line 128839 of file sqlite3.c.

References sqlite3::lastRowid.

                                                                              {
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(db) ){
     (void)SQLITE_MISUSE_BKPT;
     return 0;
   }
 #endif
   return db->lastRowid;
 }

SQLITE_API const char *SQLITE_STDCALL sqlite3_libversion ( void )

Definition at line 128033 of file sqlite3.c.

References sqlite3_version.

128033 { return sqlite3_version; }

sqlite3_version

SQLITE_API const char sqlite3_version[]

Definition: sqlite3.c:355

SQLITE_API int SQLITE_STDCALL sqlite3_libversion_number ( void )

Definition at line 128044 of file sqlite3.c.

128044 { return SQLITE_VERSION_NUMBER; }

SQLITE_VERSION_NUMBER

#define SQLITE_VERSION_NUMBER

Definition: sqlite3.c:322

SQLITE_API int SQLITE_STDCALL sqlite3_limit	(	sqlite3 *	db,
		int	id,
		int	newVal
	)

Definition at line 130323 of file sqlite3.c.

References sqlite3::aLimit.

Referenced by sqlite3Pragma().

                                                                                    {
   int oldLimit;
 
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(db) ){
     (void)SQLITE_MISUSE_BKPT;
     return -1;
   }
 #endif
 
   /* EVIDENCE-OF: R-30189-54097 For each limit category SQLITE_LIMIT_NAME
   ** there is a hard upper bound set at compile-time by a C preprocessor
   ** macro called SQLITE_MAX_NAME. (The "_LIMIT_" in the name is changed to
   ** "_MAX_".)
   */
   assert( aHardLimit[SQLITE_LIMIT_LENGTH]==SQLITE_MAX_LENGTH );
   assert( aHardLimit[SQLITE_LIMIT_SQL_LENGTH]==SQLITE_MAX_SQL_LENGTH );
   assert( aHardLimit[SQLITE_LIMIT_COLUMN]==SQLITE_MAX_COLUMN );
   assert( aHardLimit[SQLITE_LIMIT_EXPR_DEPTH]==SQLITE_MAX_EXPR_DEPTH );
   assert( aHardLimit[SQLITE_LIMIT_COMPOUND_SELECT]==SQLITE_MAX_COMPOUND_SELECT);
   assert( aHardLimit[SQLITE_LIMIT_VDBE_OP]==SQLITE_MAX_VDBE_OP );
   assert( aHardLimit[SQLITE_LIMIT_FUNCTION_ARG]==SQLITE_MAX_FUNCTION_ARG );
   assert( aHardLimit[SQLITE_LIMIT_ATTACHED]==SQLITE_MAX_ATTACHED );
   assert( aHardLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH]==
                                                SQLITE_MAX_LIKE_PATTERN_LENGTH );
   assert( aHardLimit[SQLITE_LIMIT_VARIABLE_NUMBER]==SQLITE_MAX_VARIABLE_NUMBER);
   assert( aHardLimit[SQLITE_LIMIT_TRIGGER_DEPTH]==SQLITE_MAX_TRIGGER_DEPTH );
   assert( aHardLimit[SQLITE_LIMIT_WORKER_THREADS]==SQLITE_MAX_WORKER_THREADS );
   assert( SQLITE_LIMIT_WORKER_THREADS==(SQLITE_N_LIMIT-1) );
 
 
   if( limitId<0 || limitId>=SQLITE_N_LIMIT ){
     return -1;
   }
   oldLimit = db->aLimit[limitId];
   if( newLimit>=0 ){                   /* IMP: R-52476-28732 */
     if( newLimit>aHardLimit[limitId] ){
       newLimit = aHardLimit[limitId];  /* IMP: R-51463-25634 */
     }
     db->aLimit[limitId] = newLimit;
   }
   return oldLimit;                     /* IMP: R-53341-35419 */
 }

SQLITE_API int SQLITE_STDCALL sqlite3_load_extension	(	sqlite3 *	db,
		const char *	zFile,
		const char *	zProc,
		char **	pzErrMsg
	)

Definition at line 102923 of file sqlite3.c.

References sqlite3::mutex, sqlite3_mutex_enter(), sqlite3_mutex_leave(), and sqlite3ApiExit().

  {
   int rc;
   sqlite3_mutex_enter(db->mutex);
   rc = sqlite3LoadExtension(db, zFile, zProc, pzErrMsg);
   rc = sqlite3ApiExit(db, rc);
   sqlite3_mutex_leave(db->mutex);
   return rc;
 }

Here is the call graph for this function:

SQLITE_API void SQLITE_CDECL sqlite3_log	(	int	iErrCode,
		const char *	zFormat,
			...
	)

Definition at line 22403 of file sqlite3.c.

References Sqlite3Config::xLog.

Referenced by sqlite3CantopenError(), sqlite3CorruptError(), sqlite3MisuseError(), sqlite3RunParser(), and sqlite3VdbeExec().

                                                                                 {
   va_list ap;                             /* Vararg list */
   if( sqlite3GlobalConfig.xLog ){
     va_start(ap, zFormat);
     renderLogMsg(iErrCode, zFormat, ap);
     va_end(ap);
   }
 }

SQLITE_API void *SQLITE_STDCALL sqlite3_malloc ( int n )

Definition at line 20854 of file sqlite3.c.

References sqlite3_initialize(), and sqlite3Malloc().

Referenced by sqlite3BitvecBuiltinTest(), and sqlite3OsInit().

                                                      {
 #ifndef SQLITE_OMIT_AUTOINIT
   if( sqlite3_initialize() ) return 0;
 #endif
   return n<=0 ? 0 : sqlite3Malloc(n);
 }

Here is the call graph for this function:

SQLITE_API void *SQLITE_STDCALL sqlite3_malloc64 ( sqlite3_uint64 n )

Definition at line 20860 of file sqlite3.c.

References sqlite3_initialize(), and sqlite3Malloc().

                                                                   {
 #ifndef SQLITE_OMIT_AUTOINIT
   if( sqlite3_initialize() ) return 0;
 #endif
   return sqlite3Malloc(n);
 }

Here is the call graph for this function:

SQLITE_API SQLITE_DEPRECATED int SQLITE_STDCALL sqlite3_memory_alarm	(	void()(void , sqlite3_int64, int)	,
		void *	,
		sqlite3_int64
	)

SQLITE_API int SQLITE_STDCALL sqlite3_memory_alarm	(	void()(void pArg, sqlite3_int64 used, int N)	xCallback,
		void *	pArg,
		sqlite3_int64	iThreshold
	)

Definition at line 20645 of file sqlite3.c.

  {
   return sqlite3MemoryAlarm(xCallback, pArg, iThreshold);
 }

SQLITE_API sqlite3_int64 SQLITE_STDCALL sqlite3_memory_highwater ( int resetFlag )

Definition at line 20763 of file sqlite3.c.

References sqlite3_status().

                                                                                {
   int n, mx;
   sqlite3_int64 res;
   sqlite3_status(SQLITE_STATUS_MEMORY_USED, &n, &mx, resetFlag);
   res = (sqlite3_int64)mx;  /* Work around bug in Borland C. Ticket #3216 */
   return res;
 }

Here is the call graph for this function:

SQLITE_API sqlite3_int64 SQLITE_STDCALL sqlite3_memory_used ( void )

Definition at line 20750 of file sqlite3.c.

References sqlite3_status().

Referenced by sqlite3_soft_heap_limit64().

                                                                  {
   int n, mx;
   sqlite3_int64 res;
   sqlite3_status(SQLITE_STATUS_MEMORY_USED, &n, &mx, 0);
   res = (sqlite3_int64)n;  /* Work around bug in Borland C. Ticket #3216 */
   return res;
 }

Here is the call graph for this function:

SQLITE_API char *SQLITE_CDECL sqlite3_mprintf	(	const char *	zFormat,
			...
	)

Definition at line 22331 of file sqlite3.c.

References sqlite3_initialize().

Referenced by sqlite3_get_table(), sqlite3InvalidFunction(), sqlite3ParseUri(), and sqlite3Pragma().

                                                                        {
   va_list ap;
   char *z;
 #ifndef SQLITE_OMIT_AUTOINIT
   if( sqlite3_initialize() ) return 0;
 #endif
   va_start(ap, zFormat);
   z = sqlite3_vmprintf(zFormat, ap);
   va_end(ap);
   return z;
 }

Here is the call graph for this function:

SQLITE_API sqlite3_uint64 SQLITE_STDCALL sqlite3_msize ( void * p )

Definition at line 21001 of file sqlite3.c.

References Sqlite3Config::m, and sqlite3_mem_methods::xSize.

                                                                {
   assert( sqlite3MemdebugNoType(p, (u8)~MEMTYPE_HEAP) );
   assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) );
   return (sqlite3_uint64)sqlite3GlobalConfig.m.xSize(p);
 }

SQLITE_API sqlite3_mutex *SQLITE_STDCALL sqlite3_mutex_alloc ( int id )

Definition at line 19185 of file sqlite3.c.

References Sqlite3Config::mutex, sqlite3_initialize(), and sqlite3MutexInit().

                                                                     {
 #ifndef SQLITE_OMIT_AUTOINIT
   if( id<=SQLITE_MUTEX_RECURSIVE && sqlite3_initialize() ) return 0;
   if( id>SQLITE_MUTEX_RECURSIVE && sqlite3MutexInit() ) return 0;
 #endif
   return sqlite3GlobalConfig.mutex.xMutexAlloc(id);
 }

Here is the call graph for this function:

SQLITE_API void SQLITE_STDCALL sqlite3_mutex_enter ( sqlite3_mutex * p )

Definition at line 19214 of file sqlite3.c.

References Sqlite3Config::mutex, and sqlite3_mutex_methods::xMutexEnter.

Referenced by sqlite3_auto_extension(), sqlite3_backup_finish(), sqlite3_backup_init(), sqlite3_backup_step(), sqlite3_blob_close(), sqlite3_blob_open(), sqlite3_blob_reopen(), sqlite3_busy_handler(), sqlite3_cancel_auto_extension(), sqlite3_clear_bindings(), sqlite3_collation_needed(), sqlite3_collation_needed16(), sqlite3_commit_hook(), sqlite3_create_collation16(), sqlite3_create_collation_v2(), sqlite3_create_function16(), sqlite3_create_function_v2(), sqlite3_db_release_memory(), sqlite3_db_status(), sqlite3_declare_vtab(), sqlite3_enable_load_extension(), sqlite3_errmsg(), sqlite3_errmsg16(), sqlite3_exec(), sqlite3_extended_result_codes(), sqlite3_file_control(), sqlite3_finalize(), sqlite3_free(), sqlite3_initialize(), sqlite3_load_extension(), sqlite3_next_stmt(), sqlite3_overload_function(), sqlite3_profile(), sqlite3_progress_handler(), sqlite3_randomness(), sqlite3_reset(), sqlite3_reset_auto_extension(), sqlite3_rollback_hook(), sqlite3_set_authorizer(), sqlite3_soft_heap_limit64(), sqlite3_status64(), sqlite3_step(), sqlite3_table_column_metadata(), sqlite3_test_control(), sqlite3_trace(), sqlite3_update_hook(), sqlite3_vfs_find(), sqlite3_vfs_register(), sqlite3_vfs_unregister(), sqlite3_vtab_config(), sqlite3_wal_checkpoint_v2(), sqlite3_wal_hook(), sqlite3AutoLoadExtensions(), sqlite3BackupUpdate(), sqlite3BtreeOpen(), sqlite3Malloc(), sqlite3Realloc(), sqlite3ScratchFree(), sqlite3ScratchMalloc(), and sqlite3TransferBindings().

                                                                     {
   if( p ){
     sqlite3GlobalConfig.mutex.xMutexEnter(p);
   }
 }

SQLITE_API void SQLITE_STDCALL sqlite3_mutex_free ( sqlite3_mutex * p )

Definition at line 19204 of file sqlite3.c.

References Sqlite3Config::mutex, and sqlite3_mutex_methods::xMutexFree.

Referenced by sqlite3_initialize(), and sqlite3LeaveMutexAndCloseZombie().

                                                                    {
   if( p ){
     sqlite3GlobalConfig.mutex.xMutexFree(p);
   }
 }

SQLITE_API int SQLITE_STDCALL sqlite3_mutex_held ( sqlite3_mutex * )

SQLITE_API void SQLITE_STDCALL sqlite3_mutex_leave ( sqlite3_mutex * p )

Definition at line 19238 of file sqlite3.c.

References Sqlite3Config::mutex, and sqlite3_mutex_methods::xMutexLeave.

Referenced by sqlite3_auto_extension(), sqlite3_backup_init(), sqlite3_backup_step(), sqlite3_bind_double(), sqlite3_bind_int64(), sqlite3_bind_null(), sqlite3_bind_zeroblob(), sqlite3_blob_close(), sqlite3_blob_open(), sqlite3_blob_reopen(), sqlite3_busy_handler(), sqlite3_cancel_auto_extension(), sqlite3_clear_bindings(), sqlite3_collation_needed(), sqlite3_collation_needed16(), sqlite3_commit_hook(), sqlite3_create_collation16(), sqlite3_create_collation_v2(), sqlite3_create_function16(), sqlite3_create_function_v2(), sqlite3_db_release_memory(), sqlite3_db_status(), sqlite3_declare_vtab(), sqlite3_enable_load_extension(), sqlite3_errmsg(), sqlite3_errmsg16(), sqlite3_exec(), sqlite3_extended_result_codes(), sqlite3_file_control(), sqlite3_free(), sqlite3_initialize(), sqlite3_load_extension(), sqlite3_next_stmt(), sqlite3_overload_function(), sqlite3_profile(), sqlite3_progress_handler(), sqlite3_randomness(), sqlite3_reset(), sqlite3_reset_auto_extension(), sqlite3_rollback_hook(), sqlite3_set_authorizer(), sqlite3_soft_heap_limit64(), sqlite3_status64(), sqlite3_step(), sqlite3_table_column_metadata(), sqlite3_test_control(), sqlite3_trace(), sqlite3_update_hook(), sqlite3_vfs_find(), sqlite3_vfs_register(), sqlite3_vfs_unregister(), sqlite3_vtab_config(), sqlite3_wal_checkpoint_v2(), sqlite3_wal_hook(), sqlite3AutoLoadExtensions(), sqlite3BackupUpdate(), sqlite3BtreeOpen(), sqlite3LeaveMutexAndCloseZombie(), sqlite3Malloc(), sqlite3Realloc(), sqlite3ScratchFree(), sqlite3ScratchMalloc(), and sqlite3TransferBindings().

                                                                     {
   if( p ){
     sqlite3GlobalConfig.mutex.xMutexLeave(p);
   }
 }

SQLITE_API int SQLITE_STDCALL sqlite3_mutex_notheld ( sqlite3_mutex * )

SQLITE_API int SQLITE_STDCALL sqlite3_mutex_try ( sqlite3_mutex * p )

Definition at line 19224 of file sqlite3.c.

References Sqlite3Config::mutex, and sqlite3_mutex_methods::xMutexTry.

                                                                  {
   int rc = SQLITE_OK;
   if( p ){
     return sqlite3GlobalConfig.mutex.xMutexTry(p);
   }
   return rc;
 }

SQLITE_API sqlite3_stmt *SQLITE_STDCALL sqlite3_next_stmt	(	sqlite3 *	pDb,
		sqlite3_stmt *	pStmt
	)

Definition at line 70482 of file sqlite3.c.

References sqlite3::mutex, Vdbe::pNext, sqlite3::pVdbe, sqlite3_mutex_enter(), and sqlite3_mutex_leave().

                                                                                             {
   sqlite3_stmt *pNext;
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(pDb) ){
     (void)SQLITE_MISUSE_BKPT;
     return 0;
   }
 #endif
   sqlite3_mutex_enter(pDb->mutex);
   if( pStmt==0 ){
     pNext = (sqlite3_stmt*)pDb->pVdbe;
   }else{
     pNext = (sqlite3_stmt*)((Vdbe*)pStmt)->pNext;
   }
   sqlite3_mutex_leave(pDb->mutex);
   return pNext;
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_open	(	const char *	filename,
		sqlite3 **	ppDb
	)

Definition at line 130908 of file sqlite3.c.

  {
   return openDatabase(zFilename, ppDb,
                       SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, 0);
 }

SQLITE_API int SQLITE_STDCALL sqlite3_open16	(	const void *	filename,
		sqlite3 **	ppDb
	)

Definition at line 130928 of file sqlite3.c.

References Db::pSchema, sqlite3_initialize(), sqlite3ApiExit(), sqlite3ValueFree(), sqlite3ValueNew(), and sqlite3ValueSetStr().

  {
   char const *zFilename8;   /* zFilename encoded in UTF-8 instead of UTF-16 */
   sqlite3_value *pVal;
   int rc;
 
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( ppDb==0 ) return SQLITE_MISUSE_BKPT;
 #endif
   *ppDb = 0;
 #ifndef SQLITE_OMIT_AUTOINIT
   rc = sqlite3_initialize();
   if( rc ) return rc;
 #endif
   if( zFilename==0 ) zFilename = "\000\000";
   pVal = sqlite3ValueNew(0);
   sqlite3ValueSetStr(pVal, -1, zFilename, SQLITE_UTF16NATIVE, SQLITE_STATIC);
   zFilename8 = sqlite3ValueText(pVal, SQLITE_UTF8);
   if( zFilename8 ){
     rc = openDatabase(zFilename8, ppDb,
                       SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, 0);
     assert( *ppDb || rc==SQLITE_NOMEM );
     if( rc==SQLITE_OK && !DbHasProperty(*ppDb, 0, DB_SchemaLoaded) ){
       SCHEMA_ENC(*ppDb) = ENC(*ppDb) = SQLITE_UTF16NATIVE;
     }
   }else{
     rc = SQLITE_NOMEM;
   }
   sqlite3ValueFree(pVal);
 
   return sqlite3ApiExit(0, rc);
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_open_v2	(	const char *	filename,
		sqlite3 **	ppDb,
		int	flags,
		const char *	zVfs
	)

Definition at line 130915 of file sqlite3.c.

  {
   return openDatabase(filename, ppDb, (unsigned int)flags, zVfs);
 }

SQLITE_API int SQLITE_STDCALL sqlite3_os_end ( void )

Definition at line 33028 of file sqlite3.c.

Referenced by sqlite3_shutdown().

                                                   { 
   return SQLITE_OK; 
 }

SQLITE_API int SQLITE_STDCALL sqlite3_os_init ( void )

Definition at line 32929 of file sqlite3.c.

References sqlite3_vfs_register().

Referenced by sqlite3OsInit().

                                                    { 
   /* 
   ** The following macro defines an initializer for an sqlite3_vfs object.
   ** The name of the VFS is NAME.  The pAppData is a pointer to a pointer
   ** to the "finder" function.  (pAppData is a pointer to a pointer because
   ** silly C90 rules prohibit a void* from being cast to a function pointer
   ** and so we have to go through the intermediate pointer to avoid problems
   ** when compiling with -pedantic-errors on GCC.)
   **
   ** The FINDER parameter to this macro is the name of the pointer to the
   ** finder-function.  The finder-function returns a pointer to the
   ** sqlite_io_methods object that implements the desired locking
   ** behaviors.  See the division above that contains the IOMETHODS
   ** macro for addition information on finder-functions.
   **
   ** Most finders simply return a pointer to a fixed sqlite3_io_methods
   ** object.  But the "autolockIoFinder" available on MacOSX does a little
   ** more than that; it looks at the filesystem type that hosts the 
   ** database file and tries to choose an locking method appropriate for
   ** that filesystem time.
   */
   #define UNIXVFS(VFSNAME, FINDER) {                        \
     3,                    /* iVersion */                    \
     sizeof(unixFile),     /* szOsFile */                    \
     MAX_PATHNAME,         /* mxPathname */                  \
     0,                    /* pNext */                       \
     VFSNAME,              /* zName */                       \
     (void*)&FINDER,       /* pAppData */                    \
     unixOpen,             /* xOpen */                       \
     unixDelete,           /* xDelete */                     \
     unixAccess,           /* xAccess */                     \
     unixFullPathname,     /* xFullPathname */               \
     unixDlOpen,           /* xDlOpen */                     \
     unixDlError,          /* xDlError */                    \
     unixDlSym,            /* xDlSym */                      \
     unixDlClose,          /* xDlClose */                    \
     unixRandomness,       /* xRandomness */                 \
     unixSleep,            /* xSleep */                      \
     unixCurrentTime,      /* xCurrentTime */                \
     unixGetLastError,     /* xGetLastError */               \
     unixCurrentTimeInt64, /* xCurrentTimeInt64 */           \
     unixSetSystemCall,    /* xSetSystemCall */              \
     unixGetSystemCall,    /* xGetSystemCall */              \
     unixNextSystemCall,   /* xNextSystemCall */             \
   }
 
   /*
   ** All default VFSes for unix are contained in the following array.
   **
   ** Note that the sqlite3_vfs.pNext field of the VFS object is modified
   ** by the SQLite core when the VFS is registered.  So the following
   ** array cannot be const.
   */
   static sqlite3_vfs aVfs[] = {
 #if SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__)
     UNIXVFS("unix",          autolockIoFinder ),
 #elif OS_VXWORKS
     UNIXVFS("unix",          vxworksIoFinder ),
 #else
     UNIXVFS("unix",          posixIoFinder ),
 #endif
     UNIXVFS("unix-none",     nolockIoFinder ),
     UNIXVFS("unix-dotfile",  dotlockIoFinder ),
     UNIXVFS("unix-excl",     posixIoFinder ),
 #if OS_VXWORKS
     UNIXVFS("unix-namedsem", semIoFinder ),
 #endif
 #if SQLITE_ENABLE_LOCKING_STYLE || OS_VXWORKS
     UNIXVFS("unix-posix",    posixIoFinder ),
 #endif
 #if SQLITE_ENABLE_LOCKING_STYLE
     UNIXVFS("unix-flock",    flockIoFinder ),
 #endif
 #if SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__)
     UNIXVFS("unix-afp",      afpIoFinder ),
     UNIXVFS("unix-nfs",      nfsIoFinder ),
     UNIXVFS("unix-proxy",    proxyIoFinder ),
 #endif
   };
   unsigned int i;          /* Loop counter */
 
   /* Double-check that the aSyscall[] array has been constructed
   ** correctly.  See ticket [bb3a86e890c8e96ab] */
   assert( ArraySize(aSyscall)==25 );
 
   /* Register all VFSes defined in the aVfs[] array */
   for(i=0; i<(sizeof(aVfs)/sizeof(sqlite3_vfs)); i++){
     sqlite3_vfs_register(&aVfs[i], i==0);
   }
   return SQLITE_OK; 
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_overload_function	(	sqlite3 *	db,
		const char *	zFuncName,
		int	nArg
	)

Definition at line 129699 of file sqlite3.c.

References sqlite3::mutex, sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3ApiExit(), sqlite3CreateFunc(), sqlite3FindFunction(), sqlite3InvalidFunction(), and sqlite3Strlen30().

Referenced by sqlite3RegisterBuiltinFunctions().

  {
   int nName = sqlite3Strlen30(zName);
   int rc = SQLITE_OK;
 
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(db) || zName==0 || nArg<-2 ){
     return SQLITE_MISUSE_BKPT;
   }
 #endif
   sqlite3_mutex_enter(db->mutex);
   if( sqlite3FindFunction(db, zName, nName, nArg, SQLITE_UTF8, 0)==0 ){
     rc = sqlite3CreateFunc(db, zName, nArg, SQLITE_UTF8,
                            0, sqlite3InvalidFunction, 0, 0, 0);
   }
   rc = sqlite3ApiExit(db, rc);
   sqlite3_mutex_leave(db->mutex);
   return rc;
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_prepare	(	sqlite3 *	db,
		const char *	zSql,
		int	nByte,
		sqlite3_stmt **	ppStmt,
		const char **	pzTail
	)

Definition at line 106361 of file sqlite3.c.

Referenced by sqlite3InitCallback().

  {
   int rc;
   rc = sqlite3LockAndPrepare(db,zSql,nBytes,0,0,ppStmt,pzTail);
   assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 );  /* VERIFY: F13021 */
   return rc;
 }

SQLITE_API int SQLITE_STDCALL sqlite3_prepare16	(	sqlite3 *	db,
		const void *	zSql,
		int	nByte,
		sqlite3_stmt **	ppStmt,
		const void **	pzTail
	)

Definition at line 106449 of file sqlite3.c.

  {
   int rc;
   rc = sqlite3Prepare16(db,zSql,nBytes,0,ppStmt,pzTail);
   assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 );  /* VERIFY: F13021 */
   return rc;
 }

SQLITE_API int SQLITE_STDCALL sqlite3_prepare16_v2	(	sqlite3 *	db,
		const void *	zSql,
		int	nByte,
		sqlite3_stmt **	ppStmt,
		const void **	pzTail
	)

Definition at line 106461 of file sqlite3.c.

  {
   int rc;
   rc = sqlite3Prepare16(db,zSql,nBytes,1,ppStmt,pzTail);
   assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 );  /* VERIFY: F13021 */
   return rc;
 }

SQLITE_API int SQLITE_STDCALL sqlite3_prepare_v2	(	sqlite3 *	db,
		const char *	zSql,
		int	nByte,
		sqlite3_stmt **	ppStmt,
		const char **	pzTail
	)

Definition at line 106373 of file sqlite3.c.

Referenced by sqlite3_exec().

  {
   int rc;
   rc = sqlite3LockAndPrepare(db,zSql,nBytes,1,0,ppStmt,pzTail);
   assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 );  /* VERIFY: F13021 */
   return rc;
 }

SQLITE_API void *SQLITE_STDCALL sqlite3_profile	(	sqlite3 *	db,
		void()(void , const char *, sqlite3_uint64)	xProfile,
		void *	pArg
	)

Definition at line 129755 of file sqlite3.c.

References sqlite3::mutex, sqlite3::pProfileArg, sqlite3_mutex_enter(), sqlite3_mutex_leave(), and sqlite3::xProfile.

  {
   void *pOld;
 
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(db) ){
     (void)SQLITE_MISUSE_BKPT;
     return 0;
   }
 #endif
   sqlite3_mutex_enter(db->mutex);
   pOld = db->pProfileArg;
   db->xProfile = xProfile;
   db->pProfileArg = pArg;
   sqlite3_mutex_leave(db->mutex);
   return pOld;
 }

Here is the call graph for this function:

SQLITE_API void SQLITE_STDCALL sqlite3_progress_handler	(	sqlite3 *	db,
		int	nOps,
		int()(void )	xProgress,
		void *	pArg
	)

Definition at line 129438 of file sqlite3.c.

References sqlite3::mutex, sqlite3::nProgressOps, sqlite3::pProgressArg, sqlite3_mutex_enter(), sqlite3_mutex_leave(), and sqlite3::xProgress.

  {
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(db) ){
     (void)SQLITE_MISUSE_BKPT;
     return;
   }
 #endif
   sqlite3_mutex_enter(db->mutex);
   if( nOps>0 ){
     db->xProgress = xProgress;
     db->nProgressOps = (unsigned)nOps;
     db->pProgressArg = pArg;
   }else{
     db->xProgress = 0;
     db->nProgressOps = 0;
     db->pProgressArg = 0;
   }
   sqlite3_mutex_leave(db->mutex);
 }

Here is the call graph for this function:

SQLITE_API void SQLITE_STDCALL sqlite3_randomness	(	int	N,
		void *	P
	)

Definition at line 22539 of file sqlite3.c.

References sqlite3_initialize(), sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3_vfs_find(), sqlite3MutexAlloc(), and sqlite3OsRandomness().

Referenced by sqlite3_test_control(), sqlite3BitvecBuiltinTest(), sqlite3VdbeExec(), and sqlite3WalFrames().

                                                                     {
   unsigned char t;
   unsigned char *zBuf = pBuf;
 
   /* The "wsdPrng" macro will resolve to the pseudo-random number generator
   ** state vector.  If writable static data is unsupported on the target,
   ** we have to locate the state vector at run-time.  In the more common
   ** case where writable static data is supported, wsdPrng can refer directly
   ** to the "sqlite3Prng" state vector declared above.
   */
 #ifdef SQLITE_OMIT_WSD
   struct sqlite3PrngType *p = &GLOBAL(struct sqlite3PrngType, sqlite3Prng);
 # define wsdPrng p[0]
 #else
 # define wsdPrng sqlite3Prng
 #endif
 
 #if SQLITE_THREADSAFE
   sqlite3_mutex *mutex;
 #endif
 
 #ifndef SQLITE_OMIT_AUTOINIT
   if( sqlite3_initialize() ) return;
 #endif
 
 #if SQLITE_THREADSAFE
   mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_PRNG);
 #endif
 
   sqlite3_mutex_enter(mutex);
   if( N<=0 || pBuf==0 ){
     wsdPrng.isInit = 0;
     sqlite3_mutex_leave(mutex);
     return;
   }
 
   /* Initialize the state of the random number generator once,
   ** the first time this routine is called.  The seed value does
   ** not need to contain a lot of randomness since we are not
   ** trying to do secure encryption or anything like that...
   **
   ** Nothing in this file or anywhere else in SQLite does any kind of
   ** encryption.  The RC4 algorithm is being used as a PRNG (pseudo-random
   ** number generator) not as an encryption device.
   */
   if( !wsdPrng.isInit ){
     int i;
     char k[256];
     wsdPrng.j = 0;
     wsdPrng.i = 0;
     sqlite3OsRandomness(sqlite3_vfs_find(0), 256, k);
     for(i=0; i<256; i++){
       wsdPrng.s[i] = (u8)i;
     }
     for(i=0; i<256; i++){
       wsdPrng.j += wsdPrng.s[i] + k[i];
       t = wsdPrng.s[wsdPrng.j];
       wsdPrng.s[wsdPrng.j] = wsdPrng.s[i];
       wsdPrng.s[i] = t;
     }
     wsdPrng.isInit = 1;
   }
 
   assert( N>0 );
   do{
     wsdPrng.i++;
     t = wsdPrng.s[wsdPrng.i];
     wsdPrng.j += t;
     wsdPrng.s[wsdPrng.i] = wsdPrng.s[wsdPrng.j];
     wsdPrng.s[wsdPrng.j] = t;
     t += wsdPrng.s[wsdPrng.i];
     *(zBuf++) = wsdPrng.s[t];
   }while( --N );
   sqlite3_mutex_leave(mutex);
 }

Here is the call graph for this function:

SQLITE_API void *SQLITE_STDCALL sqlite3_realloc	(	void *	pOld,
		int	n
	)

Definition at line 21119 of file sqlite3.c.

References sqlite3_initialize(), and sqlite3Realloc().

                                                                   {
 #ifndef SQLITE_OMIT_AUTOINIT
   if( sqlite3_initialize() ) return 0;
 #endif
   if( n<0 ) n = 0;  /* IMP: R-26507-47431 */
   return sqlite3Realloc(pOld, n);
 }

Here is the call graph for this function:

SQLITE_API void *SQLITE_STDCALL sqlite3_realloc64	(	void *	pOld,
		sqlite3_uint64	n
	)

Definition at line 21126 of file sqlite3.c.

References sqlite3_initialize(), and sqlite3Realloc().

Referenced by sqlite3DbRealloc().

                                                                                {
 #ifndef SQLITE_OMIT_AUTOINIT
   if( sqlite3_initialize() ) return 0;
 #endif
   return sqlite3Realloc(pOld, n);
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_release_memory ( int n )

Definition at line 20545 of file sqlite3.c.

Referenced by sqlite3_soft_heap_limit64().

                                                            {
 #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
   return sqlite3PcacheReleaseMemory(n);
 #else
   /* IMPLEMENTATION-OF: R-34391-24921 The sqlite3_release_memory() routine
   ** is a no-op returning zero if SQLite is not compiled with
   ** SQLITE_ENABLE_MEMORY_MANAGEMENT. */
   UNUSED_PARAMETER(n);
   return 0;
 #endif
 }

SQLITE_API int SQLITE_STDCALL sqlite3_reset ( sqlite3_stmt * pStmt )

Definition at line 69097 of file sqlite3.c.

References Vdbe::db, sqlite3::mutex, sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3ApiExit(), sqlite3VdbeReset(), and sqlite3VdbeRewind().

Referenced by sqlite3_step().

                                                                 {
   int rc;
   if( pStmt==0 ){
     rc = SQLITE_OK;
   }else{
     Vdbe *v = (Vdbe*)pStmt;
     sqlite3_mutex_enter(v->db->mutex);
     rc = sqlite3VdbeReset(v);
     sqlite3VdbeRewind(v);
     assert( (rc & (v->db->errMask))==rc );
     rc = sqlite3ApiExit(v->db, rc);
     sqlite3_mutex_leave(v->db->mutex);
   }
   return rc;
 }

Here is the call graph for this function:

SQLITE_API void SQLITE_STDCALL sqlite3_reset_auto_extension ( void )

Definition at line 103079 of file sqlite3.c.

References sqlite3_free(), sqlite3_initialize(), sqlite3_mutex_enter(), sqlite3_mutex_leave(), and sqlite3MutexAlloc().

Referenced by sqlite3_shutdown().

                                                                  {
 #ifndef SQLITE_OMIT_AUTOINIT
   if( sqlite3_initialize()==SQLITE_OK )
 #endif
   {
 #if SQLITE_THREADSAFE
     sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER);
 #endif
     wsdAutoextInit;
     sqlite3_mutex_enter(mutex);
     sqlite3_free(wsdAutoext.aExt);
     wsdAutoext.aExt = 0;
     wsdAutoext.nExt = 0;
     sqlite3_mutex_leave(mutex);
   }
 }

Here is the call graph for this function:

SQLITE_API void SQLITE_STDCALL sqlite3_result_blob	(	sqlite3_context *	pCtx,
		const void *	z,
		int	n,
		void()(void )	xDel
	)

Definition at line 69259 of file sqlite3.c.

  {
   assert( n>=0 );
   assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
   setResultStrOrError(pCtx, z, n, 0, xDel);
 }

SQLITE_API void SQLITE_STDCALL sqlite3_result_blob64	(	sqlite3_context *	pCtx,
		const void *	z,
		sqlite3_uint64	n,
		void()(void )	xDel
	)

Definition at line 69269 of file sqlite3.c.

  {
   assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
   assert( xDel!=SQLITE_DYNAMIC );
   if( n>0x7fffffff ){
     (void)invokeValueDestructor(z, xDel, pCtx);
   }else{
     setResultStrOrError(pCtx, z, (int)n, 0, xDel);
   }
 }

SQLITE_API void SQLITE_STDCALL sqlite3_result_double	(	sqlite3_context *	pCtx,
		double	rVal
	)

Definition at line 69283 of file sqlite3.c.

References sqlite3_context::pOut, and sqlite3VdbeMemSetDouble().

                                                                                         {
   assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
   sqlite3VdbeMemSetDouble(pCtx->pOut, rVal);
 }

Here is the call graph for this function:

SQLITE_API void SQLITE_STDCALL sqlite3_result_error	(	sqlite3_context *	pCtx,
		const char *	z,
		int	n
	)

Definition at line 69287 of file sqlite3.c.

References sqlite3_context::fErrorOrAux, sqlite3_context::isError, sqlite3_context::pOut, and sqlite3VdbeMemSetStr().

Referenced by sqlite3InvalidFunction().

                                                                                                 {
   assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
   pCtx->isError = SQLITE_ERROR;
   pCtx->fErrorOrAux = 1;
   sqlite3VdbeMemSetStr(pCtx->pOut, z, n, SQLITE_UTF8, SQLITE_TRANSIENT);
 }

Here is the call graph for this function:

SQLITE_API void SQLITE_STDCALL sqlite3_result_error16	(	sqlite3_context *	pCtx,
		const void *	z,
		int	n
	)

Definition at line 69294 of file sqlite3.c.

References sqlite3_context::fErrorOrAux, and sqlite3_context::isError.

                                                                                                   {
   assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
   pCtx->isError = SQLITE_ERROR;
   pCtx->fErrorOrAux = 1;
   sqlite3VdbeMemSetStr(pCtx->pOut, z, n, SQLITE_UTF16NATIVE, SQLITE_TRANSIENT);
 }

SQLITE_API void SQLITE_STDCALL sqlite3_result_error_code	(	sqlite3_context *	pCtx,
		int	errCode
	)

Definition at line 69375 of file sqlite3.c.

References sqlite3_context::fErrorOrAux, sqlite3_value::flags, sqlite3_context::isError, sqlite3_context::pOut, sqlite3ErrStr(), and sqlite3VdbeMemSetStr().

                                                                                             {
   pCtx->isError = errCode;
   pCtx->fErrorOrAux = 1;
 #ifdef SQLITE_DEBUG
   if( pCtx->pVdbe ) pCtx->pVdbe->rcApp = errCode;
 #endif
   if( pCtx->pOut->flags & MEM_Null ){
     sqlite3VdbeMemSetStr(pCtx->pOut, sqlite3ErrStr(errCode), -1, 
                          SQLITE_UTF8, SQLITE_STATIC);
   }
 }

Here is the call graph for this function:

SQLITE_API void SQLITE_STDCALL sqlite3_result_error_nomem ( sqlite3_context * pCtx )

Definition at line 69397 of file sqlite3.c.

References sqlite3_value::db, sqlite3_context::fErrorOrAux, sqlite3_context::isError, sqlite3::mallocFailed, sqlite3_context::pOut, and sqlite3VdbeMemSetNull().

                                                                                 {
   assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
   sqlite3VdbeMemSetNull(pCtx->pOut);
   pCtx->isError = SQLITE_NOMEM;
   pCtx->fErrorOrAux = 1;
   pCtx->pOut->db->mallocFailed = 1;
 }

Here is the call graph for this function:

SQLITE_API void SQLITE_STDCALL sqlite3_result_error_toobig ( sqlite3_context * pCtx )

Definition at line 69388 of file sqlite3.c.

References sqlite3_context::fErrorOrAux, sqlite3_context::isError, sqlite3_context::pOut, and sqlite3VdbeMemSetStr().

                                                                                  {
   assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
   pCtx->isError = SQLITE_TOOBIG;
   pCtx->fErrorOrAux = 1;
   sqlite3VdbeMemSetStr(pCtx->pOut, "string or blob too big", -1, 
                        SQLITE_UTF8, SQLITE_STATIC);
 }

Here is the call graph for this function:

SQLITE_API void SQLITE_STDCALL sqlite3_result_int	(	sqlite3_context *	pCtx,
		int	iVal
	)

Definition at line 69301 of file sqlite3.c.

References sqlite3_context::pOut, and sqlite3VdbeMemSetInt64().

                                                                                   {
   assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
   sqlite3VdbeMemSetInt64(pCtx->pOut, (i64)iVal);
 }

Here is the call graph for this function:

SQLITE_API void SQLITE_STDCALL sqlite3_result_int64	(	sqlite3_context *	pCtx,
		sqlite3_int64	iVal
	)

Definition at line 69305 of file sqlite3.c.

References sqlite3_context::pOut, and sqlite3VdbeMemSetInt64().

                                                                                     {
   assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
   sqlite3VdbeMemSetInt64(pCtx->pOut, iVal);
 }

Here is the call graph for this function:

SQLITE_API void SQLITE_STDCALL sqlite3_result_null ( sqlite3_context * pCtx )

Definition at line 69309 of file sqlite3.c.

References sqlite3_context::pOut, and sqlite3VdbeMemSetNull().

                                                                          {
   assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
   sqlite3VdbeMemSetNull(pCtx->pOut);
 }

Here is the call graph for this function:

SQLITE_API void SQLITE_STDCALL sqlite3_result_text	(	sqlite3_context *	pCtx,
		const char *	z,
		int	n,
		void()(void )	xDel
	)

Definition at line 69313 of file sqlite3.c.

  {
   assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
   setResultStrOrError(pCtx, z, n, SQLITE_UTF8, xDel);
 }

SQLITE_API void SQLITE_STDCALL sqlite3_result_text16	(	sqlite3_context *	pCtx,
		const void *	z,
		int	n,
		void()(void )	xDel
	)

Definition at line 69339 of file sqlite3.c.

  {
   assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
   setResultStrOrError(pCtx, z, n, SQLITE_UTF16NATIVE, xDel);
 }

SQLITE_API void SQLITE_STDCALL sqlite3_result_text16be	(	sqlite3_context *	pCtx,
		const void *	z,
		int	n,
		void()(void )	xDel
	)

Definition at line 69348 of file sqlite3.c.

  {
   assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
   setResultStrOrError(pCtx, z, n, SQLITE_UTF16BE, xDel);
 }

SQLITE_API void SQLITE_STDCALL sqlite3_result_text16le	(	sqlite3_context *	pCtx,
		const void *	z,
		int	n,
		void()(void )	xDel
	)

Definition at line 69357 of file sqlite3.c.

  {
   assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
   setResultStrOrError(pCtx, z, n, SQLITE_UTF16LE, xDel);
 }

SQLITE_API void SQLITE_STDCALL sqlite3_result_text64	(	sqlite3_context *	pCtx,
		const char *	z,
		sqlite3_uint64	n,
		void()(void )	xDel,
		unsigned char	encoding
	)

Definition at line 69322 of file sqlite3.c.

  {
   assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
   assert( xDel!=SQLITE_DYNAMIC );
   if( enc==SQLITE_UTF16 ) enc = SQLITE_UTF16NATIVE;
   if( n>0x7fffffff ){
     (void)invokeValueDestructor(z, xDel, pCtx);
   }else{
     setResultStrOrError(pCtx, z, (int)n, enc, xDel);
   }
 }

SQLITE_API void SQLITE_STDCALL sqlite3_result_value	(	sqlite3_context *	pCtx,
		sqlite3_value *	pValue
	)

Definition at line 69367 of file sqlite3.c.

References sqlite3_context::pOut, and sqlite3VdbeMemCopy().

                                                                                                  {
   assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
   sqlite3VdbeMemCopy(pCtx->pOut, pValue);
 }

Here is the call graph for this function:

SQLITE_API void SQLITE_STDCALL sqlite3_result_zeroblob	(	sqlite3_context *	pCtx,
		int	n
	)

Definition at line 69371 of file sqlite3.c.

References sqlite3_context::pOut, and sqlite3VdbeMemSetZeroBlob().

                                                                                     {
   assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
   sqlite3VdbeMemSetZeroBlob(pCtx->pOut, n);
 }

Here is the call graph for this function:

SQLITE_API void *SQLITE_STDCALL sqlite3_rollback_hook	(	sqlite3 *	db,
		void()(void )	xCallback,
		void *	pArg
	)

Definition at line 129832 of file sqlite3.c.

References sqlite3::mutex, sqlite3::pRollbackArg, sqlite3_mutex_enter(), sqlite3_mutex_leave(), and sqlite3::xRollbackCallback.

  {
   void *pRet;
 
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(db) ){
     (void)SQLITE_MISUSE_BKPT;
     return 0;
   }
 #endif
   sqlite3_mutex_enter(db->mutex);
   pRet = db->pRollbackArg;
   db->xRollbackCallback = xCallback;
   db->pRollbackArg = pArg;
   sqlite3_mutex_leave(db->mutex);
   return pRet;
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_rtree_geometry_callback	(	sqlite3 *	db,
		const char *	zGeom,
		int()(sqlite3_rtree_geometry , int, sqlite3_rtree_dbl , int )	xGeom,
		void *	pContext
	)

SQLITE_API int SQLITE_STDCALL sqlite3_rtree_query_callback	(	sqlite3 *	db,
		const char *	zQueryFunc,
		int()(sqlite3_rtree_query_info )	xQueryFunc,
		void *	pContext,
		void()(void )	xDestructor
	)

SQLITE_API int SQLITE_STDCALL sqlite3_set_authorizer	(	sqlite3 *	db,
		int()(void , int, const char , const char , const char , const char )	xAuth,
		void *	pUserData
	)

Definition at line 90618 of file sqlite3.c.

References sqlite3::mutex, sqlite3::pAuthArg, sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3ExpirePreparedStatements(), and sqlite3::xAuth.

  {
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
 #endif
   sqlite3_mutex_enter(db->mutex);
   db->xAuth = (sqlite3_xauth)xAuth;
   db->pAuthArg = pArg;
   sqlite3ExpirePreparedStatements(db);
   sqlite3_mutex_leave(db->mutex);
   return SQLITE_OK;
 }

Here is the call graph for this function:

SQLITE_API void SQLITE_STDCALL sqlite3_set_auxdata	(	sqlite3_context *	pCtx,
		int	N,
		void *	pAux,
		void()(void )	xDelete
	)

Definition at line 69748 of file sqlite3.c.

References sqlite3_context::fErrorOrAux, AuxData::iArg, AuxData::iOp, sqlite3_context::iOp, sqlite3_context::isError, AuxData::pAux, Vdbe::pAuxData, AuxData::pNext, sqlite3_context::pVdbe, and AuxData::xDelete.

  {
   AuxData *pAuxData;
   Vdbe *pVdbe = pCtx->pVdbe;
 
   assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
   if( iArg<0 ) goto failed;
 #ifdef SQLITE_ENABLE_STAT3_OR_STAT4
   if( pVdbe==0 ) goto failed;
 #else
   assert( pVdbe!=0 );
 #endif
 
   for(pAuxData=pVdbe->pAuxData; pAuxData; pAuxData=pAuxData->pNext){
     if( pAuxData->iOp==pCtx->iOp && pAuxData->iArg==iArg ) break;
   }
   if( pAuxData==0 ){
     pAuxData = sqlite3DbMallocZero(pVdbe->db, sizeof(AuxData));
     if( !pAuxData ) goto failed;
     pAuxData->iOp = pCtx->iOp;
     pAuxData->iArg = iArg;
     pAuxData->pNext = pVdbe->pAuxData;
     pVdbe->pAuxData = pAuxData;
     if( pCtx->fErrorOrAux==0 ){
       pCtx->isError = 0;
       pCtx->fErrorOrAux = 1;
     }
   }else if( pAuxData->xDelete ){
     pAuxData->xDelete(pAuxData->pAux);
   }
 
   pAuxData->pAux = pAux;
   pAuxData->xDelete = xDelete;
   return;
 
 failed:
   if( xDelete ){
     xDelete(pAux);
   }
 }

SQLITE_API int SQLITE_STDCALL sqlite3_shutdown ( void )

Definition at line 128272 of file sqlite3.c.

References Sqlite3Config::isInit, Sqlite3Config::isMallocInit, Sqlite3Config::isMutexInit, Sqlite3Config::isPCacheInit, sqlite3_data_directory, sqlite3_os_end(), sqlite3_reset_auto_extension(), sqlite3_temp_directory, sqlite3MallocEnd(), sqlite3MutexEnd(), and sqlite3PcacheShutdown().

                                                     {
 #ifdef SQLITE_OMIT_WSD
   int rc = sqlite3_wsd_init(4096, 24);
   if( rc!=SQLITE_OK ){
     return rc;
   }
 #endif
 
   if( sqlite3GlobalConfig.isInit ){
 #ifdef SQLITE_EXTRA_SHUTDOWN
     void SQLITE_EXTRA_SHUTDOWN(void);
     SQLITE_EXTRA_SHUTDOWN();
 #endif
     sqlite3_os_end();
     sqlite3_reset_auto_extension();
     sqlite3GlobalConfig.isInit = 0;
   }
   if( sqlite3GlobalConfig.isPCacheInit ){
     sqlite3PcacheShutdown();
     sqlite3GlobalConfig.isPCacheInit = 0;
   }
   if( sqlite3GlobalConfig.isMallocInit ){
     sqlite3MallocEnd();
     sqlite3GlobalConfig.isMallocInit = 0;
 
 #ifndef SQLITE_OMIT_SHUTDOWN_DIRECTORIES
     /* The heap subsystem has now been shutdown and these values are supposed
     ** to be NULL or point to memory that was obtained from sqlite3_malloc(),
     ** which would rely on that heap subsystem; therefore, make sure these
     ** values cannot refer to heap memory that was just invalidated when the
     ** heap subsystem was shutdown.  This is only done if the current call to
     ** this function resulted in the heap subsystem actually being shutdown.
     */
     sqlite3_data_directory = 0;
     sqlite3_temp_directory = 0;
 #endif
   }
   if( sqlite3GlobalConfig.isMutexInit ){
     sqlite3MutexEnd();
     sqlite3GlobalConfig.isMutexInit = 0;
   }
 
   return SQLITE_OK;
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_sleep ( int ms )

Definition at line 131267 of file sqlite3.c.

References sqlite3_vfs_find(), and sqlite3OsSleep().

                                                    {
   sqlite3_vfs *pVfs;
   int rc;
   pVfs = sqlite3_vfs_find(0);
   if( pVfs==0 ) return 0;
 
   /* This function works in milliseconds, but the underlying OsSleep() 
   ** API uses microseconds. Hence the 1000's.
   */
   rc = (sqlite3OsSleep(pVfs, 1000*ms)/1000);
   return rc;
 }

Here is the call graph for this function:

SQLITE_API char *SQLITE_CDECL sqlite3_snprintf	(	int	n,
		char *	zBuf,
		const char *	zFormat,
			...
	)

Definition at line 22371 of file sqlite3.c.

Referenced by sqlite3VdbeList(), and sqlite3VdbeMemStringify().

                                                                                            {
   char *z;
   va_list ap;
   va_start(ap,zFormat);
   z = sqlite3_vsnprintf(n, zBuf, zFormat, ap);
   va_end(ap);
   return z;
 }

SQLITE_API void SQLITE_STDCALL sqlite3_soft_heap_limit ( int N )

Definition at line 20678 of file sqlite3.c.

References sqlite3_soft_heap_limit64().

                                                              {
   if( n<0 ) n = 0;
   sqlite3_soft_heap_limit64(n);
 }

Here is the call graph for this function:

SQLITE_API sqlite3_int64 SQLITE_STDCALL sqlite3_soft_heap_limit64 ( sqlite3_int64 N )

Definition at line 20658 of file sqlite3.c.

References sqlite3_initialize(), sqlite3_memory_used(), sqlite3_mutex_enter(), sqlite3_mutex_leave(), and sqlite3_release_memory().

Referenced by sqlite3_soft_heap_limit(), and sqlite3Pragma().

                                                                                   {
   sqlite3_int64 priorLimit;
   sqlite3_int64 excess;
 #ifndef SQLITE_OMIT_AUTOINIT
   int rc = sqlite3_initialize();
   if( rc ) return -1;
 #endif
   sqlite3_mutex_enter(mem0.mutex);
   priorLimit = mem0.alarmThreshold;
   sqlite3_mutex_leave(mem0.mutex);
   if( n<0 ) return priorLimit;
   if( n>0 ){
     sqlite3MemoryAlarm(softHeapLimitEnforcer, 0, n);
   }else{
     sqlite3MemoryAlarm(0, 0, 0);
   }
   excess = sqlite3_memory_used() - n;
   if( excess>0 ) sqlite3_release_memory((int)(excess & 0x7fffffff));
   return priorLimit;
 }

Here is the call graph for this function:

SQLITE_API const char *SQLITE_STDCALL sqlite3_sourceid ( void )

Definition at line 128039 of file sqlite3.c.

Referenced by sqlite3CantopenError(), sqlite3CorruptError(), and sqlite3MisuseError().

128039 { return SQLITE_SOURCE_ID; }

SQLITE_SOURCE_ID

#define SQLITE_SOURCE_ID

Definition: sqlite3.c:323

SQLITE_API const char *SQLITE_STDCALL sqlite3_sql ( sqlite3_stmt * pStmt )

Definition at line 64871 of file sqlite3.c.

References Vdbe::isPrepareV2, and Vdbe::zSql.

Referenced by sqlite3Reprepare().

                                                                       {
   Vdbe *p = (Vdbe *)pStmt;
   return (p && p->isPrepareV2) ? p->zSql : 0;
 }

SQLITE_API int SQLITE_STDCALL sqlite3_status	(	int	op,
		int *	pCurrent,
		int *	pHighwater,
		int	resetFlag
	)

Definition at line 15134 of file sqlite3.c.

References sqlite3_status64().

Referenced by sqlite3_memory_highwater(), and sqlite3_memory_used().

                                                                                                    {
   sqlite3_int64 iCur, iHwtr;
   int rc;
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( pCurrent==0 || pHighwater==0 ) return SQLITE_MISUSE_BKPT;
 #endif
   rc = sqlite3_status64(op, &iCur, &iHwtr, resetFlag);
   if( rc==0 ){
     *pCurrent = (int)iCur;
     *pHighwater = (int)iHwtr;
   }
   return rc;
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_status64	(	int	op,
		sqlite3_int64 *	pCurrent,
		sqlite3_int64 *	pHighwater,
		int	resetFlag
	)

Definition at line 15109 of file sqlite3.c.

References sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3MallocMutex(), and sqlite3Pcache1Mutex().

Referenced by sqlite3_status().

  {
   sqlite3_mutex *pMutex;
   wsdStatInit;
   if( op<0 || op>=ArraySize(wsdStat.nowValue) ){
     return SQLITE_MISUSE_BKPT;
   }
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( pCurrent==0 || pHighwater==0 ) return SQLITE_MISUSE_BKPT;
 #endif
   pMutex = statMutex[op] ? sqlite3Pcache1Mutex() : sqlite3MallocMutex();
   sqlite3_mutex_enter(pMutex);
   *pCurrent = wsdStat.nowValue[op];
   *pHighwater = wsdStat.mxValue[op];
   if( resetFlag ){
     wsdStat.mxValue[op] = wsdStat.nowValue[op];
   }
   sqlite3_mutex_leave(pMutex);
   (void)pMutex;  /* Prevent warning when SQLITE_THREADSAFE=0 */
   return SQLITE_OK;
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_step ( sqlite3_stmt * pStmt )

Definition at line 69570 of file sqlite3.c.

References Vdbe::db, Vdbe::doingRerun, sqlite3::mallocFailed, sqlite3::mutex, Vdbe::pc, sqlite3::pErr, Vdbe::rc, sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3_reset(), sqlite3_value_text(), sqlite3ApiExit(), sqlite3DbFree(), sqlite3DbStrDup(), sqlite3Reprepare(), and Vdbe::zErrMsg.

Referenced by sqlite3_exec().

                                                                {
   int rc = SQLITE_OK;      /* Result from sqlite3Step() */
   int rc2 = SQLITE_OK;     /* Result from sqlite3Reprepare() */
   Vdbe *v = (Vdbe*)pStmt;  /* the prepared statement */
   int cnt = 0;             /* Counter to prevent infinite loop of reprepares */
   sqlite3 *db;             /* The database connection */
 
   if( vdbeSafetyNotNull(v) ){
     return SQLITE_MISUSE_BKPT;
   }
   db = v->db;
   sqlite3_mutex_enter(db->mutex);
   v->doingRerun = 0;
   while( (rc = sqlite3Step(v))==SQLITE_SCHEMA
          && cnt++ < SQLITE_MAX_SCHEMA_RETRY ){
     int savedPc = v->pc;
     rc2 = rc = sqlite3Reprepare(v);
     if( rc!=SQLITE_OK) break;
     sqlite3_reset(pStmt);
     if( savedPc>=0 ) v->doingRerun = 1;
     assert( v->expired==0 );
   }
   if( rc2!=SQLITE_OK ){
     /* This case occurs after failing to recompile an sql statement. 
     ** The error message from the SQL compiler has already been loaded 
     ** into the database handle. This block copies the error message 
     ** from the database handle into the statement and sets the statement
     ** program counter to 0 to ensure that when the statement is 
     ** finalized or reset the parser error message is available via
     ** sqlite3_errmsg() and sqlite3_errcode().
     */
     const char *zErr = (const char *)sqlite3_value_text(db->pErr); 
     sqlite3DbFree(db, v->zErrMsg);
     if( !db->mallocFailed ){
       v->zErrMsg = sqlite3DbStrDup(db, zErr);
       v->rc = rc2;
     } else {
       v->zErrMsg = 0;
       v->rc = rc = SQLITE_NOMEM;
     }
   }
   rc = sqlite3ApiExit(db, rc);
   sqlite3_mutex_leave(db->mutex);
   return rc;
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_stmt_busy ( sqlite3_stmt * pStmt )

Definition at line 70471 of file sqlite3.c.

References Vdbe::magic, and Vdbe::pc.

                                                                     {
   Vdbe *v = (Vdbe*)pStmt;
   return v!=0 && v->pc>=0 && v->magic==VDBE_MAGIC_RUN;
 }

SQLITE_API int SQLITE_STDCALL sqlite3_stmt_readonly ( sqlite3_stmt * pStmt )

Definition at line 70464 of file sqlite3.c.

References Vdbe::readOnly.

                                                                         {
   return pStmt ? ((Vdbe*)pStmt)->readOnly : 1;
 }

SQLITE_API SQLITE_EXPERIMENTAL int SQLITE_STDCALL sqlite3_stmt_scanstatus	(	sqlite3_stmt *	pStmt,
		int	idx,
		int	iScanStatusOp,
		void *	pOut
	)

SQLITE_API SQLITE_EXPERIMENTAL void SQLITE_STDCALL sqlite3_stmt_scanstatus_reset ( sqlite3_stmt * )

SQLITE_API int SQLITE_STDCALL sqlite3_stmt_status	(	sqlite3_stmt *	pStmt,
		int	op,
		int	resetFlg
	)

Definition at line 70503 of file sqlite3.c.

References Vdbe::aCounter.

                                                                                              {
   Vdbe *pVdbe = (Vdbe*)pStmt;
   u32 v;
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !pStmt ){
     (void)SQLITE_MISUSE_BKPT;
     return 0;
   }
 #endif
   v = pVdbe->aCounter[op];
   if( resetFlag ) pVdbe->aCounter[op] = 0;
   return (int)v;
 }

SQLITE_API int SQLITE_STDCALL sqlite3_strglob	(	const char *	zGlob,
		const char *	zStr
	)

Definition at line 97197 of file sqlite3.c.

                                                                                             {
   return patternCompare((u8*)zGlobPattern, (u8*)zString, &globInfo, 0)==0;
 }

SQLITE_API int SQLITE_STDCALL sqlite3_stricmp	(	const char *	zLeft,
		const char *	zRight
	)

Definition at line 23691 of file sqlite3.c.

Referenced by sqlite3_blob_open(), sqlite3_table_column_metadata(), sqlite3AddPrimaryKey(), sqlite3CodeVerifyNamedSchema(), sqlite3CreateForeignKey(), sqlite3CreateIndex(), sqlite3DbNameToBtree(), sqlite3DropTrigger(), sqlite3FindDbName(), sqlite3FindIndex(), sqlite3FindTable(), sqlite3FkCheck(), sqlite3FkLocateIndex(), sqlite3IdListIndex(), sqlite3Insert(), sqlite3IsRowid(), sqlite3MatchSpanName(), sqlite3Pragma(), sqlite3TriggerList(), sqlite3Update(), sqlite3VdbeExec(), and sqlite3WithAdd().

                                                                                     {
   register unsigned char *a, *b;
   if( zLeft==0 ){
     return zRight ? -1 : 0;
   }else if( zRight==0 ){
     return 1;
   }
   a = (unsigned char *)zLeft;
   b = (unsigned char *)zRight;
   while( *a!=0 && UpperToLower[*a]==UpperToLower[*b]){ a++; b++; }
   return UpperToLower[*a] - UpperToLower[*b];
 }

SQLITE_API int SQLITE_STDCALL sqlite3_strnicmp	(	const char *	zLeft,
		const char *	zRight,
		int	N
	)

Definition at line 23703 of file sqlite3.c.

Referenced by sqlite3_compileoption_used(), sqlite3_complete(), sqlite3BeginTrigger(), sqlite3CheckObjectName(), sqlite3CreateIndex(), sqlite3DropTable(), sqlite3InitCallback(), sqlite3JoinType(), sqlite3MatchSpanName(), and sqlite3Pragma().

                                                                                             {
   register unsigned char *a, *b;
   if( zLeft==0 ){
     return zRight ? -1 : 0;
   }else if( zRight==0 ){
     return 1;
   }
   a = (unsigned char *)zLeft;
   b = (unsigned char *)zRight;
   while( N-- > 0 && *a!=0 && UpperToLower[*a]==UpperToLower[*b]){ a++; b++; }
   return N<0 ? 0 : UpperToLower[*a] - UpperToLower[*b];
 }

SQLITE_API int SQLITE_STDCALL sqlite3_table_column_metadata	(	sqlite3 *	db,
		const char *	zDbName,
		const char *	zTableName,
		const char *	zColumnName,
		char const **	pzDataType,
		char const **	pzCollSeq,
		int *	pNotNull,
		int *	pPrimaryKey,
		int *	pAutoinc
	)

Definition at line 131149 of file sqlite3.c.

References Table::aCol, Column::colFlags, Table::iPKey, sqlite3::mutex, Table::nCol, Column::notNull, Table::pSelect, sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3_stricmp(), sqlite3ApiExit(), sqlite3BtreeEnterAll(), sqlite3BtreeLeaveAll(), sqlite3DbFree(), sqlite3ErrorWithMsg(), sqlite3FindTable(), sqlite3Init(), sqlite3IsRowid(), sqlite3MPrintf(), Table::tabFlags, Column::zColl, Column::zName, and Column::zType.

  {
   int rc;
   char *zErrMsg = 0;
   Table *pTab = 0;
   Column *pCol = 0;
   int iCol = 0;
   char const *zDataType = 0;
   char const *zCollSeq = 0;
   int notnull = 0;
   int primarykey = 0;
   int autoinc = 0;
 
 
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(db) || zTableName==0 ){
     return SQLITE_MISUSE_BKPT;
   }
 #endif
 
   /* Ensure the database schema has been loaded */
   sqlite3_mutex_enter(db->mutex);
   sqlite3BtreeEnterAll(db);
   rc = sqlite3Init(db, &zErrMsg);
   if( SQLITE_OK!=rc ){
     goto error_out;
   }
 
   /* Locate the table in question */
   pTab = sqlite3FindTable(db, zTableName, zDbName);
   if( !pTab || pTab->pSelect ){
     pTab = 0;
     goto error_out;
   }
 
   /* Find the column for which info is requested */
   if( zColumnName==0 ){
     /* Query for existance of table only */
   }else{
     for(iCol=0; iCol<pTab->nCol; iCol++){
       pCol = &pTab->aCol[iCol];
       if( 0==sqlite3StrICmp(pCol->zName, zColumnName) ){
         break;
       }
     }
     if( iCol==pTab->nCol ){
       if( HasRowid(pTab) && sqlite3IsRowid(zColumnName) ){
         iCol = pTab->iPKey;
         pCol = iCol>=0 ? &pTab->aCol[iCol] : 0;
       }else{
         pTab = 0;
         goto error_out;
       }
     }
   }
 
   /* The following block stores the meta information that will be returned
   ** to the caller in local variables zDataType, zCollSeq, notnull, primarykey
   ** and autoinc. At this point there are two possibilities:
   ** 
   **     1. The specified column name was rowid", "oid" or "_rowid_" 
   **        and there is no explicitly declared IPK column. 
   **
   **     2. The table is not a view and the column name identified an 
   **        explicitly declared column. Copy meta information from *pCol.
   */ 
   if( pCol ){
     zDataType = pCol->zType;
     zCollSeq = pCol->zColl;
     notnull = pCol->notNull!=0;
     primarykey  = (pCol->colFlags & COLFLAG_PRIMKEY)!=0;
     autoinc = pTab->iPKey==iCol && (pTab->tabFlags & TF_Autoincrement)!=0;
   }else{
     zDataType = "INTEGER";
     primarykey = 1;
   }
   if( !zCollSeq ){
     zCollSeq = "BINARY";
   }
 
 error_out:
   sqlite3BtreeLeaveAll(db);
 
   /* Whether the function call succeeded or failed, set the output parameters
   ** to whatever their local counterparts contain. If an error did occur,
   ** this has the effect of zeroing all output parameters.
   */
   if( pzDataType ) *pzDataType = zDataType;
   if( pzCollSeq ) *pzCollSeq = zCollSeq;
   if( pNotNull ) *pNotNull = notnull;
   if( pPrimaryKey ) *pPrimaryKey = primarykey;
   if( pAutoinc ) *pAutoinc = autoinc;
 
   if( SQLITE_OK==rc && !pTab ){
     sqlite3DbFree(db, zErrMsg);
     zErrMsg = sqlite3MPrintf(db, "no such table column: %s.%s", zTableName,
         zColumnName);
     rc = SQLITE_ERROR;
   }
   sqlite3ErrorWithMsg(db, rc, (zErrMsg?"%s":0), zErrMsg);
   sqlite3DbFree(db, zErrMsg);
   rc = sqlite3ApiExit(db, rc);
   sqlite3_mutex_leave(db->mutex);
   return rc;
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_CDECL sqlite3_test_control	(	int	op,
			...
	)

Definition at line 131330 of file sqlite3.c.

References sqlite3::aDb, sqlite3::sqlite3InitInfo::busy, Sqlite3Config::isInit, sqlite3::mutex, sqlite3::sqlite3InitInfo::newTnum, Db::pBt, sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3_randomness(), sqlite3BenignMallocHooks(), sqlite3BitvecBuiltinTest(), sqlite3BtreeSetPageSize(), sqlite3FaultSim(), sqlite3KeywordCode(), sqlite3PendingByte, sqlite3PrngRestoreState(), sqlite3PrngSaveState(), sqlite3ResetAllSchemasOfConnection(), sqlite3ScratchFree(), sqlite3ScratchMalloc(), and sqlite3Strlen30().

                                                              {
   int rc = 0;
 #ifndef SQLITE_OMIT_BUILTIN_TEST
   va_list ap;
   va_start(ap, op);
   switch( op ){
 
     /*
     ** Save the current state of the PRNG.
     */
     case SQLITE_TESTCTRL_PRNG_SAVE: {
       sqlite3PrngSaveState();
       break;
     }
 
     /*
     ** Restore the state of the PRNG to the last state saved using
     ** PRNG_SAVE.  If PRNG_SAVE has never before been called, then
     ** this verb acts like PRNG_RESET.
     */
     case SQLITE_TESTCTRL_PRNG_RESTORE: {
       sqlite3PrngRestoreState();
       break;
     }
 
     /*
     ** Reset the PRNG back to its uninitialized state.  The next call
     ** to sqlite3_randomness() will reseed the PRNG using a single call
     ** to the xRandomness method of the default VFS.
     */
     case SQLITE_TESTCTRL_PRNG_RESET: {
       sqlite3_randomness(0,0);
       break;
     }
 
     /*
     **  sqlite3_test_control(BITVEC_TEST, size, program)
     **
     ** Run a test against a Bitvec object of size.  The program argument
     ** is an array of integers that defines the test.  Return -1 on a
     ** memory allocation error, 0 on success, or non-zero for an error.
     ** See the sqlite3BitvecBuiltinTest() for additional information.
     */
     case SQLITE_TESTCTRL_BITVEC_TEST: {
       int sz = va_arg(ap, int);
       int *aProg = va_arg(ap, int*);
       rc = sqlite3BitvecBuiltinTest(sz, aProg);
       break;
     }
 
     /*
     **  sqlite3_test_control(FAULT_INSTALL, xCallback)
     **
     ** Arrange to invoke xCallback() whenever sqlite3FaultSim() is called,
     ** if xCallback is not NULL.
     **
     ** As a test of the fault simulator mechanism itself, sqlite3FaultSim(0)
     ** is called immediately after installing the new callback and the return
     ** value from sqlite3FaultSim(0) becomes the return from
     ** sqlite3_test_control().
     */
     case SQLITE_TESTCTRL_FAULT_INSTALL: {
       /* MSVC is picky about pulling func ptrs from va lists.
       ** http://support.microsoft.com/kb/47961
       ** sqlite3GlobalConfig.xTestCallback = va_arg(ap, int(*)(int));
       */
       typedef int(*TESTCALLBACKFUNC_t)(int);
       sqlite3GlobalConfig.xTestCallback = va_arg(ap, TESTCALLBACKFUNC_t);
       rc = sqlite3FaultSim(0);
       break;
     }
 
     /*
     **  sqlite3_test_control(BENIGN_MALLOC_HOOKS, xBegin, xEnd)
     **
     ** Register hooks to call to indicate which malloc() failures 
     ** are benign.
     */
     case SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS: {
       typedef void (*void_function)(void);
       void_function xBenignBegin;
       void_function xBenignEnd;
       xBenignBegin = va_arg(ap, void_function);
       xBenignEnd = va_arg(ap, void_function);
       sqlite3BenignMallocHooks(xBenignBegin, xBenignEnd);
       break;
     }
 
     /*
     **  sqlite3_test_control(SQLITE_TESTCTRL_PENDING_BYTE, unsigned int X)
     **
     ** Set the PENDING byte to the value in the argument, if X>0.
     ** Make no changes if X==0.  Return the value of the pending byte
     ** as it existing before this routine was called.
     **
     ** IMPORTANT:  Changing the PENDING byte from 0x40000000 results in
     ** an incompatible database file format.  Changing the PENDING byte
     ** while any database connection is open results in undefined and
     ** deleterious behavior.
     */
     case SQLITE_TESTCTRL_PENDING_BYTE: {
       rc = PENDING_BYTE;
 #ifndef SQLITE_OMIT_WSD
       {
         unsigned int newVal = va_arg(ap, unsigned int);
         if( newVal ) sqlite3PendingByte = newVal;
       }
 #endif
       break;
     }
 
     /*
     **  sqlite3_test_control(SQLITE_TESTCTRL_ASSERT, int X)
     **
     ** This action provides a run-time test to see whether or not
     ** assert() was enabled at compile-time.  If X is true and assert()
     ** is enabled, then the return value is true.  If X is true and
     ** assert() is disabled, then the return value is zero.  If X is
     ** false and assert() is enabled, then the assertion fires and the
     ** process aborts.  If X is false and assert() is disabled, then the
     ** return value is zero.
     */
     case SQLITE_TESTCTRL_ASSERT: {
       volatile int x = 0;
       assert( (x = va_arg(ap,int))!=0 );
       rc = x;
       break;
     }
 
 
     /*
     **  sqlite3_test_control(SQLITE_TESTCTRL_ALWAYS, int X)
     **
     ** This action provides a run-time test to see how the ALWAYS and
     ** NEVER macros were defined at compile-time.
     **
     ** The return value is ALWAYS(X).  
     **
     ** The recommended test is X==2.  If the return value is 2, that means
     ** ALWAYS() and NEVER() are both no-op pass-through macros, which is the
     ** default setting.  If the return value is 1, then ALWAYS() is either
     ** hard-coded to true or else it asserts if its argument is false.
     ** The first behavior (hard-coded to true) is the case if
     ** SQLITE_TESTCTRL_ASSERT shows that assert() is disabled and the second
     ** behavior (assert if the argument to ALWAYS() is false) is the case if
     ** SQLITE_TESTCTRL_ASSERT shows that assert() is enabled.
     **
     ** The run-time test procedure might look something like this:
     **
     **    if( sqlite3_test_control(SQLITE_TESTCTRL_ALWAYS, 2)==2 ){
     **      // ALWAYS() and NEVER() are no-op pass-through macros
     **    }else if( sqlite3_test_control(SQLITE_TESTCTRL_ASSERT, 1) ){
     **      // ALWAYS(x) asserts that x is true. NEVER(x) asserts x is false.
     **    }else{
     **      // ALWAYS(x) is a constant 1.  NEVER(x) is a constant 0.
     **    }
     */
     case SQLITE_TESTCTRL_ALWAYS: {
       int x = va_arg(ap,int);
       rc = ALWAYS(x);
       break;
     }
 
     /*
     **   sqlite3_test_control(SQLITE_TESTCTRL_BYTEORDER);
     **
     ** The integer returned reveals the byte-order of the computer on which
     ** SQLite is running:
     **
     **       1     big-endian,    determined at run-time
     **      10     little-endian, determined at run-time
     **  432101     big-endian,    determined at compile-time
     **  123410     little-endian, determined at compile-time
     */ 
     case SQLITE_TESTCTRL_BYTEORDER: {
       rc = SQLITE_BYTEORDER*100 + SQLITE_LITTLEENDIAN*10 + SQLITE_BIGENDIAN;
       break;
     }
 
     /*   sqlite3_test_control(SQLITE_TESTCTRL_RESERVE, sqlite3 *db, int N)
     **
     ** Set the nReserve size to N for the main database on the database
     ** connection db.
     */
     case SQLITE_TESTCTRL_RESERVE: {
       sqlite3 *db = va_arg(ap, sqlite3*);
       int x = va_arg(ap,int);
       sqlite3_mutex_enter(db->mutex);
       sqlite3BtreeSetPageSize(db->aDb[0].pBt, 0, x, 0);
       sqlite3_mutex_leave(db->mutex);
       break;
     }
 
     /*  sqlite3_test_control(SQLITE_TESTCTRL_OPTIMIZATIONS, sqlite3 *db, int N)
     **
     ** Enable or disable various optimizations for testing purposes.  The 
     ** argument N is a bitmask of optimizations to be disabled.  For normal
     ** operation N should be 0.  The idea is that a test program (like the
     ** SQL Logic Test or SLT test module) can run the same SQL multiple times
     ** with various optimizations disabled to verify that the same answer
     ** is obtained in every case.
     */
     case SQLITE_TESTCTRL_OPTIMIZATIONS: {
       sqlite3 *db = va_arg(ap, sqlite3*);
       db->dbOptFlags = (u16)(va_arg(ap, int) & 0xffff);
       break;
     }
 
 #ifdef SQLITE_N_KEYWORD
     /* sqlite3_test_control(SQLITE_TESTCTRL_ISKEYWORD, const char *zWord)
     **
     ** If zWord is a keyword recognized by the parser, then return the
     ** number of keywords.  Or if zWord is not a keyword, return 0.
     ** 
     ** This test feature is only available in the amalgamation since
     ** the SQLITE_N_KEYWORD macro is not defined in this file if SQLite
     ** is built using separate source files.
     */
     case SQLITE_TESTCTRL_ISKEYWORD: {
       const char *zWord = va_arg(ap, const char*);
       int n = sqlite3Strlen30(zWord);
       rc = (sqlite3KeywordCode((u8*)zWord, n)!=TK_ID) ? SQLITE_N_KEYWORD : 0;
       break;
     }
 #endif 
 
     /* sqlite3_test_control(SQLITE_TESTCTRL_SCRATCHMALLOC, sz, &pNew, pFree);
     **
     ** Pass pFree into sqlite3ScratchFree(). 
     ** If sz>0 then allocate a scratch buffer into pNew.  
     */
     case SQLITE_TESTCTRL_SCRATCHMALLOC: {
       void *pFree, **ppNew;
       int sz;
       sz = va_arg(ap, int);
       ppNew = va_arg(ap, void**);
       pFree = va_arg(ap, void*);
       if( sz ) *ppNew = sqlite3ScratchMalloc(sz);
       sqlite3ScratchFree(pFree);
       break;
     }
 
     /*   sqlite3_test_control(SQLITE_TESTCTRL_LOCALTIME_FAULT, int onoff);
     **
     ** If parameter onoff is non-zero, configure the wrappers so that all
     ** subsequent calls to localtime() and variants fail. If onoff is zero,
     ** undo this setting.
     */
     case SQLITE_TESTCTRL_LOCALTIME_FAULT: {
       sqlite3GlobalConfig.bLocaltimeFault = va_arg(ap, int);
       break;
     }
 
     /*   sqlite3_test_control(SQLITE_TESTCTRL_NEVER_CORRUPT, int);
     **
     ** Set or clear a flag that indicates that the database file is always well-
     ** formed and never corrupt.  This flag is clear by default, indicating that
     ** database files might have arbitrary corruption.  Setting the flag during
     ** testing causes certain assert() statements in the code to be activated
     ** that demonstrat invariants on well-formed database files.
     */
     case SQLITE_TESTCTRL_NEVER_CORRUPT: {
       sqlite3GlobalConfig.neverCorrupt = va_arg(ap, int);
       break;
     }
 
 
     /*   sqlite3_test_control(SQLITE_TESTCTRL_VDBE_COVERAGE, xCallback, ptr);
     **
     ** Set the VDBE coverage callback function to xCallback with context 
     ** pointer ptr.
     */
     case SQLITE_TESTCTRL_VDBE_COVERAGE: {
 #ifdef SQLITE_VDBE_COVERAGE
       typedef void (*branch_callback)(void*,int,u8,u8);
       sqlite3GlobalConfig.xVdbeBranch = va_arg(ap,branch_callback);
       sqlite3GlobalConfig.pVdbeBranchArg = va_arg(ap,void*);
 #endif
       break;
     }
 
     /*   sqlite3_test_control(SQLITE_TESTCTRL_SORTER_MMAP, db, nMax); */
     case SQLITE_TESTCTRL_SORTER_MMAP: {
       sqlite3 *db = va_arg(ap, sqlite3*);
       db->nMaxSorterMmap = va_arg(ap, int);
       break;
     }
 
     /*   sqlite3_test_control(SQLITE_TESTCTRL_ISINIT);
     **
     ** Return SQLITE_OK if SQLite has been initialized and SQLITE_ERROR if
     ** not.
     */
     case SQLITE_TESTCTRL_ISINIT: {
       if( sqlite3GlobalConfig.isInit==0 ) rc = SQLITE_ERROR;
       break;
     }
 
     /*  sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, db, dbName, onOff, tnum);
     **
     ** This test control is used to create imposter tables.  "db" is a pointer
     ** to the database connection.  dbName is the database name (ex: "main" or
     ** "temp") which will receive the imposter.  "onOff" turns imposter mode on
     ** or off.  "tnum" is the root page of the b-tree to which the imposter
     ** table should connect.
     **
     ** Enable imposter mode only when the schema has already been parsed.  Then
     ** run a single CREATE TABLE statement to construct the imposter table in
     ** the parsed schema.  Then turn imposter mode back off again.
     **
     ** If onOff==0 and tnum>0 then reset the schema for all databases, causing
     ** the schema to be reparsed the next time it is needed.  This has the
     ** effect of erasing all imposter tables.
     */
     case SQLITE_TESTCTRL_IMPOSTER: {
       sqlite3 *db = va_arg(ap, sqlite3*);
       sqlite3_mutex_enter(db->mutex);
       db->init.iDb = sqlite3FindDbName(db, va_arg(ap,const char*));
       db->init.busy = db->init.imposterTable = va_arg(ap,int);
       db->init.newTnum = va_arg(ap,int);
       if( db->init.busy==0 && db->init.newTnum>0 ){
         sqlite3ResetAllSchemasOfConnection(db);
       }
       sqlite3_mutex_leave(db->mutex);
       break;
     }
   }
   va_end(ap);
 #endif /* SQLITE_OMIT_BUILTIN_TEST */
   return rc;
 }

Here is the call graph for this function:

SQLITE_API void SQLITE_STDCALL sqlite3_thread_cleanup ( void )

Definition at line 131141 of file sqlite3.c.

131141 {

131142 }

SQLITE_API int SQLITE_STDCALL sqlite3_threadsafe ( void )

Definition at line 128050 of file sqlite3.c.

128050 { return SQLITE_THREADSAFE; }

SQLITE_THREADSAFE

#define SQLITE_THREADSAFE

Definition: sqlite3.c:8343

SQLITE_API int SQLITE_STDCALL sqlite3_total_changes ( sqlite3 * db )

Definition at line 128865 of file sqlite3.c.

References sqlite3::nTotalChange.

                                                                 {
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(db) ){
     (void)SQLITE_MISUSE_BKPT;
     return 0;
   }
 #endif
   return db->nTotalChange;
 }

SQLITE_API void *SQLITE_STDCALL sqlite3_trace	(	sqlite3 *	db,
		void()(void , const char *)	xTrace,
		void *	pArg
	)

Definition at line 129731 of file sqlite3.c.

References sqlite3::mutex, sqlite3::pTraceArg, sqlite3_mutex_enter(), sqlite3_mutex_leave(), and sqlite3::xTrace.

                                                                                                          {
   void *pOld;
 
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(db) ){
     (void)SQLITE_MISUSE_BKPT;
     return 0;
   }
 #endif
   sqlite3_mutex_enter(db->mutex);
   pOld = db->pTraceArg;
   db->xTrace = xTrace;
   db->pTraceArg = pArg;
   sqlite3_mutex_leave(db->mutex);
   return pOld;
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_transfer_bindings	(	sqlite3_stmt *	pFromStmt,
		sqlite3_stmt *	pToStmt
	)

Definition at line 70434 of file sqlite3.c.

References Vdbe::expired, Vdbe::expmask, Vdbe::isPrepareV2, Vdbe::nVar, and sqlite3TransferBindings().

                                                                                                        {
   Vdbe *pFrom = (Vdbe*)pFromStmt;
   Vdbe *pTo = (Vdbe*)pToStmt;
   if( pFrom->nVar!=pTo->nVar ){
     return SQLITE_ERROR;
   }
   if( pTo->isPrepareV2 && pTo->expmask ){
     pTo->expired = 1;
   }
   if( pFrom->isPrepareV2 && pFrom->expmask ){
     pFrom->expired = 1;
   }
   return sqlite3TransferBindings(pFromStmt, pToStmt);
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_unlock_notify	(	sqlite3 *	pBlocked,
		void()(void *apArg, int nArg)	xNotify,
		void *	pNotifyArg
	)

SQLITE_API void *SQLITE_STDCALL sqlite3_update_hook	(	sqlite3 *	db,
		void()(void , int,char const , char const , sqlite3_int64)	xCallback,
		void *	pArg
	)

Definition at line 129807 of file sqlite3.c.

References sqlite3::mutex, sqlite3::pUpdateArg, sqlite3_mutex_enter(), sqlite3_mutex_leave(), and sqlite3::xUpdateCallback.

  {
   void *pRet;
 
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(db) ){
     (void)SQLITE_MISUSE_BKPT;
     return 0;
   }
 #endif
   sqlite3_mutex_enter(db->mutex);
   pRet = db->pUpdateArg;
   db->xUpdateCallback = xCallback;
   db->pUpdateArg = pArg;
   sqlite3_mutex_leave(db->mutex);
   return pRet;
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_uri_boolean	(	const char *	zFile,
		const char *	zParam,
		int	bDefault
	)

Definition at line 131688 of file sqlite3.c.

References sqlite3_uri_parameter(), and sqlite3GetBoolean().

Referenced by sqlite3PagerOpen().

                                                                                                        {
   const char *z = sqlite3_uri_parameter(zFilename, zParam);
   bDflt = bDflt!=0;
   return z ? sqlite3GetBoolean(z, bDflt) : bDflt;
 }

Here is the call graph for this function:

SQLITE_API sqlite3_int64 SQLITE_STDCALL sqlite3_uri_int64	(	const char *	zFilename,
		const char *	zParam,
		sqlite3_int64	bDflt
	)

Definition at line 131697 of file sqlite3.c.

References sqlite3_uri_parameter(), and sqlite3DecOrHexToI64().

  {
   const char *z = sqlite3_uri_parameter(zFilename, zParam);
   sqlite3_int64 v;
   if( z && sqlite3DecOrHexToI64(z, &v)==SQLITE_OK ){
     bDflt = v;
   }
   return bDflt;
 }

Here is the call graph for this function:

SQLITE_API const char *SQLITE_STDCALL sqlite3_uri_parameter	(	const char *	zFilename,
		const char *	zParam
	)

Definition at line 131673 of file sqlite3.c.

References sqlite3Strlen30().

Referenced by sqlite3_uri_boolean(), and sqlite3_uri_int64().

                                                                                                       {
   if( zFilename==0 || zParam==0 ) return 0;
   zFilename += sqlite3Strlen30(zFilename) + 1;
   while( zFilename[0] ){
     int x = strcmp(zFilename, zParam);
     zFilename += sqlite3Strlen30(zFilename) + 1;
     if( x==0 ) return zFilename;
     zFilename += sqlite3Strlen30(zFilename) + 1;
   }
   return 0;
 }

Here is the call graph for this function:

SQLITE_API void *SQLITE_STDCALL sqlite3_user_data ( sqlite3_context * p )

Definition at line 69621 of file sqlite3.c.

References sqlite3_context::pFunc, and FuncDef::pUserData.

                                                                      {
   assert( p && p->pFunc );
   return p->pFunc->pUserData;
 }

SQLITE_API const void *SQLITE_STDCALL sqlite3_value_blob ( sqlite3_value * pVal )

Definition at line 69140 of file sqlite3.c.

References sqlite3_value::flags, sqlite3_value::n, sqlite3_value_text(), sqlite3VdbeMemExpandBlob(), and sqlite3_value::z.

Referenced by sqlite3_column_blob().

                                                                              {
   Mem *p = (Mem*)pVal;
   if( p->flags & (MEM_Blob|MEM_Str) ){
     sqlite3VdbeMemExpandBlob(p);
     p->flags |= MEM_Blob;
     return p->n ? p->z : 0;
   }else{
     return sqlite3_value_text(pVal);
   }
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_value_bytes ( sqlite3_value * pVal )

Definition at line 69150 of file sqlite3.c.

References sqlite3ValueBytes().

Referenced by sqlite3_column_bytes().

                                                                       {
   return sqlite3ValueBytes(pVal, SQLITE_UTF8);
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_value_bytes16 ( sqlite3_value * pVal )

Definition at line 69153 of file sqlite3.c.

References sqlite3ValueBytes().

Referenced by sqlite3_column_bytes16().

                                                                         {
   return sqlite3ValueBytes(pVal, SQLITE_UTF16NATIVE);
 }

Here is the call graph for this function:

SQLITE_API double SQLITE_STDCALL sqlite3_value_double ( sqlite3_value * pVal )

Definition at line 69156 of file sqlite3.c.

References sqlite3VdbeRealValue().

Referenced by sqlite3_column_double().

                                                                           {
   return sqlite3VdbeRealValue((Mem*)pVal);
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_value_int ( sqlite3_value * pVal )

Definition at line 69159 of file sqlite3.c.

References sqlite3VdbeIntValue().

Referenced by sqlite3_column_int().

                                                                     {
   return (int)sqlite3VdbeIntValue((Mem*)pVal);
 }

Here is the call graph for this function:

SQLITE_API sqlite_int64 SQLITE_STDCALL sqlite3_value_int64 ( sqlite3_value * pVal )

Definition at line 69162 of file sqlite3.c.

References sqlite3VdbeIntValue().

Referenced by sqlite3_column_int64().

                                                                                {
   return sqlite3VdbeIntValue((Mem*)pVal);
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_value_numeric_type ( sqlite3_value * pVal )

Definition at line 71083 of file sqlite3.c.

References sqlite3_value_type().

                                                                              {
   int eType = sqlite3_value_type(pVal);
   if( eType==SQLITE_TEXT ){
     Mem *pMem = (Mem*)pVal;
     applyNumericAffinity(pMem, 0);
     eType = sqlite3_value_type(pVal);
   }
   return eType;
 }

Here is the call graph for this function:

SQLITE_API const unsigned char *SQLITE_STDCALL sqlite3_value_text ( sqlite3_value * pVal )

Definition at line 69165 of file sqlite3.c.

References sqlite3ValueText().

Referenced by sqlite3_column_text(), sqlite3_errmsg(), sqlite3_step(), sqlite3_value_blob(), and sqlite3VdbeExec().

                                                                                       {
   return (const unsigned char *)sqlite3ValueText(pVal, SQLITE_UTF8);
 }

Here is the call graph for this function:

SQLITE_API const void *SQLITE_STDCALL sqlite3_value_text16 ( sqlite3_value * pVal )

Definition at line 69169 of file sqlite3.c.

References sqlite3ValueText().

Referenced by sqlite3_column_decltype16(), sqlite3_column_name16(), sqlite3_column_text16(), and sqlite3_errmsg16().

                                                                                {
   return sqlite3ValueText(pVal, SQLITE_UTF16NATIVE);
 }

Here is the call graph for this function:

SQLITE_API const void *SQLITE_STDCALL sqlite3_value_text16be ( sqlite3_value * pVal )

Definition at line 69172 of file sqlite3.c.

References sqlite3ValueText().

                                                                                  {
   return sqlite3ValueText(pVal, SQLITE_UTF16BE);
 }

Here is the call graph for this function:

SQLITE_API const void *SQLITE_STDCALL sqlite3_value_text16le ( sqlite3_value * pVal )

Definition at line 69175 of file sqlite3.c.

References sqlite3ValueText().

                                                                                  {
   return sqlite3ValueText(pVal, SQLITE_UTF16LE);
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_value_type ( sqlite3_value * pVal )

Definition at line 69183 of file sqlite3.c.

References sqlite3_value::flags.

Referenced by sqlite3_bind_value(), sqlite3_column_type(), and sqlite3_value_numeric_type().

                                                                      {
   static const u8 aType[] = {
      SQLITE_BLOB,     /* 0x00 */
      SQLITE_NULL,     /* 0x01 */
      SQLITE_TEXT,     /* 0x02 */
      SQLITE_NULL,     /* 0x03 */
      SQLITE_INTEGER,  /* 0x04 */
      SQLITE_NULL,     /* 0x05 */
      SQLITE_INTEGER,  /* 0x06 */
      SQLITE_NULL,     /* 0x07 */
      SQLITE_FLOAT,    /* 0x08 */
      SQLITE_NULL,     /* 0x09 */
      SQLITE_FLOAT,    /* 0x0a */
      SQLITE_NULL,     /* 0x0b */
      SQLITE_INTEGER,  /* 0x0c */
      SQLITE_NULL,     /* 0x0d */
      SQLITE_INTEGER,  /* 0x0e */
      SQLITE_NULL,     /* 0x0f */
      SQLITE_BLOB,     /* 0x10 */
      SQLITE_NULL,     /* 0x11 */
      SQLITE_TEXT,     /* 0x12 */
      SQLITE_NULL,     /* 0x13 */
      SQLITE_INTEGER,  /* 0x14 */
      SQLITE_NULL,     /* 0x15 */
      SQLITE_INTEGER,  /* 0x16 */
      SQLITE_NULL,     /* 0x17 */
      SQLITE_FLOAT,    /* 0x18 */
      SQLITE_NULL,     /* 0x19 */
      SQLITE_FLOAT,    /* 0x1a */
      SQLITE_NULL,     /* 0x1b */
      SQLITE_INTEGER,  /* 0x1c */
      SQLITE_NULL,     /* 0x1d */
      SQLITE_INTEGER,  /* 0x1e */
      SQLITE_NULL,     /* 0x1f */
   };
   return aType[pVal->flags&MEM_AffMask];
 }

SQLITE_API sqlite3_vfs *SQLITE_STDCALL sqlite3_vfs_find ( const char * zVfsName )

Definition at line 16775 of file sqlite3.c.

References sqlite3_vfs::pNext, sqlite3_initialize(), sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3MutexAlloc(), and sqlite3_vfs::zName.

Referenced by sqlite3_randomness(), sqlite3_sleep(), and sqlite3ParseUri().

                                                                          {
   sqlite3_vfs *pVfs = 0;
 #if SQLITE_THREADSAFE
   sqlite3_mutex *mutex;
 #endif
 #ifndef SQLITE_OMIT_AUTOINIT
   int rc = sqlite3_initialize();
   if( rc ) return 0;
 #endif
 #if SQLITE_THREADSAFE
   mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER);
 #endif
   sqlite3_mutex_enter(mutex);
   for(pVfs = vfsList; pVfs; pVfs=pVfs->pNext){
     if( zVfs==0 ) break;
     if( strcmp(zVfs, pVfs->zName)==0 ) break;
   }
   sqlite3_mutex_leave(mutex);
   return pVfs;
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_vfs_register	(	sqlite3_vfs *	pVfs,
		int	makeDflt
	)

Definition at line 16821 of file sqlite3.c.

References sqlite3_vfs::pNext, sqlite3_initialize(), sqlite3_mutex_enter(), sqlite3_mutex_leave(), and sqlite3MutexAlloc().

Referenced by sqlite3_os_init().

                                                                                    {
   MUTEX_LOGIC(sqlite3_mutex *mutex;)
 #ifndef SQLITE_OMIT_AUTOINIT
   int rc = sqlite3_initialize();
   if( rc ) return rc;
 #endif
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( pVfs==0 ) return SQLITE_MISUSE_BKPT;
 #endif
 
   MUTEX_LOGIC( mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER); )
   sqlite3_mutex_enter(mutex);
   vfsUnlink(pVfs);
   if( makeDflt || vfsList==0 ){
     pVfs->pNext = vfsList;
     vfsList = pVfs;
   }else{
     pVfs->pNext = vfsList->pNext;
     vfsList->pNext = pVfs;
   }
   assert(vfsList);
   sqlite3_mutex_leave(mutex);
   return SQLITE_OK;
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_vfs_unregister ( sqlite3_vfs * pVfs )

Definition at line 16849 of file sqlite3.c.

References sqlite3_mutex_enter(), sqlite3_mutex_leave(), and sqlite3MutexAlloc().

                                                                        {
 #if SQLITE_THREADSAFE
   sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER);
 #endif
   sqlite3_mutex_enter(mutex);
   vfsUnlink(pVfs);
   sqlite3_mutex_leave(mutex);
   return SQLITE_OK;
 }

Here is the call graph for this function:

SQLITE_API char *SQLITE_STDCALL sqlite3_vmprintf	(	const char *	zFormat,
		va_list	ap
	)

Definition at line 22306 of file sqlite3.c.

References sqlite3_initialize(), sqlite3StrAccumFinish(), sqlite3StrAccumInit(), sqlite3VXPrintf(), and StrAccum::useMalloc.

                                                                                  {
   char *z;
   char zBase[SQLITE_PRINT_BUF_SIZE];
   StrAccum acc;
 
 #ifdef SQLITE_ENABLE_API_ARMOR  
   if( zFormat==0 ){
     (void)SQLITE_MISUSE_BKPT;
     return 0;
   }
 #endif
 #ifndef SQLITE_OMIT_AUTOINIT
   if( sqlite3_initialize() ) return 0;
 #endif
   sqlite3StrAccumInit(&acc, zBase, sizeof(zBase), SQLITE_MAX_LENGTH);
   acc.useMalloc = 2;
   sqlite3VXPrintf(&acc, 0, zFormat, ap);
   z = sqlite3StrAccumFinish(&acc);
   return z;
 }

Here is the call graph for this function:

SQLITE_API char *SQLITE_STDCALL sqlite3_vsnprintf	(	int	n,
		char *	zBuf,
		const char *	zFormat,
		va_list	ap
	)

Definition at line 22356 of file sqlite3.c.

References sqlite3StrAccumFinish(), sqlite3StrAccumInit(), sqlite3VXPrintf(), and StrAccum::useMalloc.

                                                                                                      {
   StrAccum acc;
   if( n<=0 ) return zBuf;
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( zBuf==0 || zFormat==0 ) {
     (void)SQLITE_MISUSE_BKPT;
     if( zBuf ) zBuf[0] = 0;
     return zBuf;
   }
 #endif
   sqlite3StrAccumInit(&acc, zBuf, n, 0);
   acc.useMalloc = 0;
   sqlite3VXPrintf(&acc, 0, zFormat, ap);
   return sqlite3StrAccumFinish(&acc);
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_CDECL sqlite3_vtab_config	(	sqlite3 *	db,
		int	op,
			...
	)

Definition at line 115677 of file sqlite3.c.

References sqlite3::mutex, sqlite3::pVtabCtx, sqlite3_mutex_enter(), sqlite3_mutex_leave(), and sqlite3Error().

                                                                          {
   va_list ap;
   int rc = SQLITE_OK;
 
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
 #endif
   sqlite3_mutex_enter(db->mutex);
   va_start(ap, op);
   switch( op ){
     case SQLITE_VTAB_CONSTRAINT_SUPPORT: {
       VtabCtx *p = db->pVtabCtx;
       if( !p ){
         rc = SQLITE_MISUSE_BKPT;
       }else{
         assert( p->pTab==0 || (p->pTab->tabFlags & TF_Virtual)!=0 );
         p->pVTable->bConstraint = (u8)va_arg(ap, int);
       }
       break;
     }
     default:
       rc = SQLITE_MISUSE_BKPT;
       break;
   }
   va_end(ap);
 
   if( rc!=SQLITE_OK ) sqlite3Error(db, rc);
   sqlite3_mutex_leave(db->mutex);
   return rc;
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_vtab_on_conflict ( sqlite3 * db )

Definition at line 115659 of file sqlite3.c.

References sqlite3::vtabOnConflict.

                                                                    {
   static const unsigned char aMap[] = { 
     SQLITE_ROLLBACK, SQLITE_ABORT, SQLITE_FAIL, SQLITE_IGNORE, SQLITE_REPLACE 
   };
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
 #endif
   assert( OE_Rollback==1 && OE_Abort==2 && OE_Fail==3 );
   assert( OE_Ignore==4 && OE_Replace==5 );
   assert( db->vtabOnConflict>=1 && db->vtabOnConflict<=5 );
   return (int)aMap[db->vtabOnConflict-1];
 }

SQLITE_API int SQLITE_STDCALL sqlite3_wal_autocheckpoint	(	sqlite3 *	db,
		int	N
	)

Definition at line 129886 of file sqlite3.c.

References sqlite3_wal_hook(), and sqlite3WalDefaultHook().

Referenced by sqlite3Pragma().

                                                                                  {
 #ifdef SQLITE_OMIT_WAL
   UNUSED_PARAMETER(db);
   UNUSED_PARAMETER(nFrame);
 #else
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
 #endif
   if( nFrame>0 ){
     sqlite3_wal_hook(db, sqlite3WalDefaultHook, SQLITE_INT_TO_PTR(nFrame));
   }else{
     sqlite3_wal_hook(db, 0, 0);
   }
 #endif
   return SQLITE_OK;
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_wal_checkpoint	(	sqlite3 *	db,
		const char *	zDb
	)

Definition at line 129989 of file sqlite3.c.

References sqlite3_wal_checkpoint_v2().

Referenced by sqlite3WalDefaultHook().

                                                                                   {
   /* EVIDENCE-OF: R-41613-20553 The sqlite3_wal_checkpoint(D,X) is equivalent to
   ** sqlite3_wal_checkpoint_v2(D,X,SQLITE_CHECKPOINT_PASSIVE,0,0). */
   return sqlite3_wal_checkpoint_v2(db,zDb,SQLITE_CHECKPOINT_PASSIVE,0,0);
 }

Here is the call graph for this function:

SQLITE_API int SQLITE_STDCALL sqlite3_wal_checkpoint_v2	(	sqlite3 *	db,
		const char *	zDb,
		int	eMode,
		int *	pnLog,
		int *	pnCkpt
	)

Definition at line 129934 of file sqlite3.c.

References sqlite3::busyHandler, sqlite3::mutex, BusyHandler::nBusy, sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3ApiExit(), sqlite3Checkpoint(), sqlite3Error(), sqlite3ErrorWithMsg(), and sqlite3FindDbName().

Referenced by sqlite3_wal_checkpoint().

  {
 #ifdef SQLITE_OMIT_WAL
   return SQLITE_OK;
 #else
   int rc;                         /* Return code */
   int iDb = SQLITE_MAX_ATTACHED;  /* sqlite3.aDb[] index of db to checkpoint */
 
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
 #endif
 
   /* Initialize the output variables to -1 in case an error occurs. */
   if( pnLog ) *pnLog = -1;
   if( pnCkpt ) *pnCkpt = -1;
 
   assert( SQLITE_CHECKPOINT_PASSIVE==0 );
   assert( SQLITE_CHECKPOINT_FULL==1 );
   assert( SQLITE_CHECKPOINT_RESTART==2 );
   assert( SQLITE_CHECKPOINT_TRUNCATE==3 );
   if( eMode<SQLITE_CHECKPOINT_PASSIVE || eMode>SQLITE_CHECKPOINT_TRUNCATE ){
     /* EVIDENCE-OF: R-03996-12088 The M parameter must be a valid checkpoint
     ** mode: */
     return SQLITE_MISUSE;
   }
 
   sqlite3_mutex_enter(db->mutex);
   if( zDb && zDb[0] ){
     iDb = sqlite3FindDbName(db, zDb);
   }
   if( iDb<0 ){
     rc = SQLITE_ERROR;
     sqlite3ErrorWithMsg(db, SQLITE_ERROR, "unknown database: %s", zDb);
   }else{
     db->busyHandler.nBusy = 0;
     rc = sqlite3Checkpoint(db, iDb, eMode, pnLog, pnCkpt);
     sqlite3Error(db, rc);
   }
   rc = sqlite3ApiExit(db, rc);
   sqlite3_mutex_leave(db->mutex);
   return rc;
 #endif
 }

Here is the call graph for this function:

SQLITE_API void *SQLITE_STDCALL sqlite3_wal_hook	(	sqlite3 *	db,
		int()(void , sqlite3 , const char , int)	xCallback,
		void *	pArg
	)

Definition at line 129907 of file sqlite3.c.

References sqlite3::mutex, sqlite3::pWalArg, sqlite3_mutex_enter(), sqlite3_mutex_leave(), and sqlite3::xWalCallback.

Referenced by sqlite3_wal_autocheckpoint().

  {
 #ifndef SQLITE_OMIT_WAL
   void *pRet;
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(db) ){
     (void)SQLITE_MISUSE_BKPT;
     return 0;
   }
 #endif
   sqlite3_mutex_enter(db->mutex);
   pRet = db->pWalArg;
   db->xWalCallback = xCallback;
   db->pWalArg = pArg;
   sqlite3_mutex_leave(db->mutex);
   return pRet;
 #else
   return 0;
 #endif
 }

Here is the call graph for this function:

SQLITE_PRIVATE int sqlite3AbsInt32 ( int x )

Definition at line 24700 of file sqlite3.c.

Referenced by sqlite3Pragma().

                                          {
   if( x>=0 ) return x;
   if( x==(int)0x80000000 ) return 0x7fffffff;
   return -x;
 }

SQLITE_PRIVATE void sqlite3AddCheckConstraint	(	Parse *	pParse,
		Expr *	pCheckExpr
	)

Definition at line 92158 of file sqlite3.c.

References sqlite3::aDb, Parse::constraintName, Parse::db, sqlite3::sqlite3InitInfo::iDb, Token::n, Db::pBt, Table::pCheck, Parse::pNewTable, sqlite3BtreeIsReadonly(), sqlite3ExprDelete(), sqlite3ExprListAppend(), and sqlite3ExprListSetName().

  {
 #ifndef SQLITE_OMIT_CHECK
   Table *pTab = pParse->pNewTable;
   sqlite3 *db = pParse->db;
   if( pTab && !IN_DECLARE_VTAB
    && !sqlite3BtreeIsReadonly(db->aDb[db->init.iDb].pBt)
   ){
     pTab->pCheck = sqlite3ExprListAppend(pParse, pTab->pCheck, pCheckExpr);
     if( pParse->constraintName.n ){
       sqlite3ExprListSetName(pParse, pTab->pCheck, &pParse->constraintName, 1);
     }
   }else
 #endif
   {
     sqlite3ExprDelete(pParse->db, pCheckExpr);
   }
 }

Here is the call graph for this function:

SQLITE_PRIVATE void sqlite3AddCollateType	(	Parse *	pParse,
		Token *	pToken
	)

Definition at line 92183 of file sqlite3.c.

References Table::aCol, Index::aiColumn, Index::azColl, Parse::db, Table::nCol, Table::pIndex, Parse::pNewTable, Index::pNext, sqlite3DbFree(), sqlite3LocateCollSeq(), sqlite3NameFromToken(), and Column::zColl.

                                                                        {
   Table *p;
   int i;
   char *zColl;              /* Dequoted name of collation sequence */
   sqlite3 *db;
 
   if( (p = pParse->pNewTable)==0 ) return;
   i = p->nCol-1;
   db = pParse->db;
   zColl = sqlite3NameFromToken(db, pToken);
   if( !zColl ) return;
 
   if( sqlite3LocateCollSeq(pParse, zColl) ){
     Index *pIdx;
     sqlite3DbFree(db, p->aCol[i].zColl);
     p->aCol[i].zColl = zColl;
   
     /* If the column is declared as "<name> PRIMARY KEY COLLATE <type>",
     ** then an index may have been created on this column before the
     ** collation type was added. Correct this if it is the case.
     */
     for(pIdx=p->pIndex; pIdx; pIdx=pIdx->pNext){
       assert( pIdx->nKeyCol==1 );
       if( pIdx->aiColumn[0]==i ){
         pIdx->azColl[0] = p->aCol[i].zColl;
       }
     }
   }else{
     sqlite3DbFree(db, zColl);
   }
 }

Here is the call graph for this function:

SQLITE_PRIVATE void sqlite3AddColumn	(	Parse *	pParse,
		Token *	pName
	)

Definition at line 91869 of file sqlite3.c.

References Table::aCol, Column::affinity, sqlite3::aLimit, Parse::db, Table::nCol, Parse::pNewTable, sqlite3DbFree(), sqlite3ErrorMsg(), sqlite3NameFromToken(), Column::szEst, Column::zName, and Table::zName.

                                                                  {
   Table *p;
   int i;
   char *z;
   Column *pCol;
   sqlite3 *db = pParse->db;
   if( (p = pParse->pNewTable)==0 ) return;
 #if SQLITE_MAX_COLUMN
   if( p->nCol+1>db->aLimit[SQLITE_LIMIT_COLUMN] ){
     sqlite3ErrorMsg(pParse, "too many columns on %s", p->zName);
     return;
   }
 #endif
   z = sqlite3NameFromToken(db, pName);
   if( z==0 ) return;
   for(i=0; i<p->nCol; i++){
     if( STRICMP(z, p->aCol[i].zName) ){
       sqlite3ErrorMsg(pParse, "duplicate column name: %s", z);
       sqlite3DbFree(db, z);
       return;
     }
   }
   if( (p->nCol & 0x7)==0 ){
     Column *aNew;
     aNew = sqlite3DbRealloc(db,p->aCol,(p->nCol+8)*sizeof(p->aCol[0]));
     if( aNew==0 ){
       sqlite3DbFree(db, z);
       return;
     }
     p->aCol = aNew;
   }
   pCol = &p->aCol[p->nCol];
   memset(pCol, 0, sizeof(p->aCol[0]));
   pCol->zName = z;
  
   /* If there is no type specified, columns have the default affinity
   ** 'NONE'. If there is a type specified, then sqlite3AddColumnType() will
   ** be called next to set pCol->affinity correctly.
   */
   pCol->affinity = SQLITE_AFF_NONE;
   pCol->szEst = 1;
   p->nCol++;
 }

Here is the call graph for this function:

SQLITE_PRIVATE void sqlite3AddColumnType	(	Parse *	pParse,
		Token *	pType
	)

Definition at line 92022 of file sqlite3.c.

References Table::aCol, Column::affinity, Parse::db, Table::nCol, Parse::pNewTable, sqlite3AffinityType(), sqlite3DbFree(), sqlite3NameFromToken(), Column::szEst, and Column::zType.

                                                                      {
   Table *p;
   Column *pCol;
 
   p = pParse->pNewTable;
   if( p==0 || NEVER(p->nCol<1) ) return;
   pCol = &p->aCol[p->nCol-1];
   assert( pCol->zType==0 || CORRUPT_DB );
   sqlite3DbFree(pParse->db, pCol->zType);
   pCol->zType = sqlite3NameFromToken(pParse->db, pType);
   pCol->affinity = sqlite3AffinityType(pCol->zType, &pCol->szEst);
 }

Here is the call graph for this function:

SQLITE_PRIVATE void sqlite3AddDefaultValue	(	Parse *	pParse,
		ExprSpan *	pSpan
	)

Definition at line 92045 of file sqlite3.c.

References Table::aCol, sqlite3::sqlite3InitInfo::busy, Parse::db, Table::nCol, Column::pDflt, ExprSpan::pExpr, Parse::pNewTable, sqlite3DbFree(), sqlite3DbStrNDup(), sqlite3ErrorMsg(), sqlite3ExprDelete(), sqlite3ExprDup(), sqlite3ExprIsConstantOrFunction(), Column::zDflt, ExprSpan::zEnd, Column::zName, and ExprSpan::zStart.

                                                                           {
   Table *p;
   Column *pCol;
   sqlite3 *db = pParse->db;
   p = pParse->pNewTable;
   if( p!=0 ){
     pCol = &(p->aCol[p->nCol-1]);
     if( !sqlite3ExprIsConstantOrFunction(pSpan->pExpr, db->init.busy) ){
       sqlite3ErrorMsg(pParse, "default value of column [%s] is not constant",
           pCol->zName);
     }else{
       /* A copy of pExpr is used instead of the original, as pExpr contains
       ** tokens that point to volatile memory. The 'span' of the expression
       ** is required by pragma table_info.
       */
       sqlite3ExprDelete(db, pCol->pDflt);
       pCol->pDflt = sqlite3ExprDup(db, pSpan->pExpr, EXPRDUP_REDUCE);
       sqlite3DbFree(db, pCol->zDflt);
       pCol->zDflt = sqlite3DbStrNDup(db, (char*)pSpan->zStart,
                                      (int)(pSpan->zEnd - pSpan->zStart));
     }
   }
   sqlite3ExprDelete(db, pSpan->pExpr);
 }

Here is the call graph for this function:

SQLITE_PRIVATE int sqlite3AddInt64	(	i64 *	pA,
		i64	iB
	)

Definition at line 24636 of file sqlite3.c.

Referenced by sqlite3MulInt64(), sqlite3SubInt64(), and sqlite3VdbeExec().

                                                    {
   i64 iA = *pA;
   testcase( iA==0 ); testcase( iA==1 );
   testcase( iB==-1 ); testcase( iB==0 );
   if( iB>=0 ){
     testcase( iA>0 && LARGEST_INT64 - iA == iB );
     testcase( iA>0 && LARGEST_INT64 - iA == iB - 1 );
     if( iA>0 && LARGEST_INT64 - iA < iB ) return 1;
   }else{
     testcase( iA<0 && -(iA + LARGEST_INT64) == iB + 1 );
     testcase( iA<0 && -(iA + LARGEST_INT64) == iB + 2 );
     if( iA<0 && -(iA + LARGEST_INT64) > iB + 1 ) return 1;
   }
   *pA += iB;
   return 0; 
 }

SQLITE_PRIVATE void sqlite3AddNotNull	(	Parse *	pParse,
		int	onError
	)

Definition at line 91919 of file sqlite3.c.

References Table::aCol, Table::nCol, Column::notNull, and Parse::pNewTable.

                                                                  {
   Table *p;
   p = pParse->pNewTable;
   if( p==0 || NEVER(p->nCol<1) ) return;
   p->aCol[p->nCol-1].notNull = (u8)onError;
 }

SQLITE_PRIVATE void sqlite3AddPrimaryKey	(	Parse *	pParse,
		ExprList *	pList,
		int	onError,
		int	autoInc,
		int	sortOrder
	)

Definition at line 92088 of file sqlite3.c.

References Table::aCol, Parse::addrSkipPK, Column::colFlags, Parse::db, Index::idxType, Table::iPKey, Parse::iPkSortOrder, Table::keyConf, Table::nCol, ExprList::nExpr, Parse::pNewTable, Parse::pVdbe, ExprList::ExprList_item::sortOrder, sqlite3_stricmp(), sqlite3CreateIndex(), sqlite3ErrorMsg(), sqlite3ExprListDelete(), sqlite3VdbeAddOp0(), sqlite3VdbeJumpHere(), Table::tabFlags, Column::zName, Table::zName, ExprList::ExprList_item::zName, and Column::zType.

  {
   Table *pTab = pParse->pNewTable;
   char *zType = 0;
   int iCol = -1, i;
   int nTerm;
   if( pTab==0 || IN_DECLARE_VTAB ) goto primary_key_exit;
   if( pTab->tabFlags & TF_HasPrimaryKey ){
     sqlite3ErrorMsg(pParse, 
       "table \"%s\" has more than one primary key", pTab->zName);
     goto primary_key_exit;
   }
   pTab->tabFlags |= TF_HasPrimaryKey;
   if( pList==0 ){
     iCol = pTab->nCol - 1;
     pTab->aCol[iCol].colFlags |= COLFLAG_PRIMKEY;
     zType = pTab->aCol[iCol].zType;
     nTerm = 1;
   }else{
     nTerm = pList->nExpr;
     for(i=0; i<nTerm; i++){
       for(iCol=0; iCol<pTab->nCol; iCol++){
         if( sqlite3StrICmp(pList->a[i].zName, pTab->aCol[iCol].zName)==0 ){
           pTab->aCol[iCol].colFlags |= COLFLAG_PRIMKEY;
           zType = pTab->aCol[iCol].zType;
           break;
         }
       }
     }
   }
   if( nTerm==1
    && zType && sqlite3StrICmp(zType, "INTEGER")==0
    && sortOrder==SQLITE_SO_ASC
   ){
     pTab->iPKey = iCol;
     pTab->keyConf = (u8)onError;
     assert( autoInc==0 || autoInc==1 );
     pTab->tabFlags |= autoInc*TF_Autoincrement;
     if( pList ) pParse->iPkSortOrder = pList->a[0].sortOrder;
   }else if( autoInc ){
 #ifndef SQLITE_OMIT_AUTOINCREMENT
     sqlite3ErrorMsg(pParse, "AUTOINCREMENT is only allowed on an "
        "INTEGER PRIMARY KEY");
 #endif
   }else{
     Vdbe *v = pParse->pVdbe;
     Index *p;
     if( v ) pParse->addrSkipPK = sqlite3VdbeAddOp0(v, OP_Noop);
     p = sqlite3CreateIndex(pParse, 0, 0, 0, pList, onError, 0,
                            0, sortOrder, 0);
     if( p ){
       p->idxType = SQLITE_IDXTYPE_PRIMARYKEY;
       if( v ) sqlite3VdbeJumpHere(v, pParse->addrSkipPK);
     }
     pList = 0;
   }
 
 primary_key_exit:
   sqlite3ExprListDelete(pParse->db, pList);
   return;
 }

Here is the call graph for this function:

SQLITE_PRIVATE char sqlite3AffinityType	(	const char *	zIn,
		u8 *	pszEst
	)

Definition at line 91951 of file sqlite3.c.

References sqlite3GetInt32(), and sqlite3UpperToLower.

Referenced by sqlite3AddColumnType(), sqlite3ExprAffinity(), and sqlite3ExprCodeTarget().

                                                                     {
   u32 h = 0;
   char aff = SQLITE_AFF_NUMERIC;
   const char *zChar = 0;
 
   if( zIn==0 ) return aff;
   while( zIn[0] ){
     h = (h<<8) + sqlite3UpperToLower[(*zIn)&0xff];
     zIn++;
     if( h==(('c'<<24)+('h'<<16)+('a'<<8)+'r') ){             /* CHAR */
       aff = SQLITE_AFF_TEXT;
       zChar = zIn;
     }else if( h==(('c'<<24)+('l'<<16)+('o'<<8)+'b') ){       /* CLOB */
       aff = SQLITE_AFF_TEXT;
     }else if( h==(('t'<<24)+('e'<<16)+('x'<<8)+'t') ){       /* TEXT */
       aff = SQLITE_AFF_TEXT;
     }else if( h==(('b'<<24)+('l'<<16)+('o'<<8)+'b')          /* BLOB */
         && (aff==SQLITE_AFF_NUMERIC || aff==SQLITE_AFF_REAL) ){
       aff = SQLITE_AFF_NONE;
       if( zIn[0]=='(' ) zChar = zIn;
 #ifndef SQLITE_OMIT_FLOATING_POINT
     }else if( h==(('r'<<24)+('e'<<16)+('a'<<8)+'l')          /* REAL */
         && aff==SQLITE_AFF_NUMERIC ){
       aff = SQLITE_AFF_REAL;
     }else if( h==(('f'<<24)+('l'<<16)+('o'<<8)+'a')          /* FLOA */
         && aff==SQLITE_AFF_NUMERIC ){
       aff = SQLITE_AFF_REAL;
     }else if( h==(('d'<<24)+('o'<<16)+('u'<<8)+'b')          /* DOUB */
         && aff==SQLITE_AFF_NUMERIC ){
       aff = SQLITE_AFF_REAL;
 #endif
     }else if( (h&0x00FFFFFF)==(('i'<<16)+('n'<<8)+'t') ){    /* INT */
       aff = SQLITE_AFF_INTEGER;
       break;
     }
   }
 
   /* If pszEst is not NULL, store an estimate of the field size.  The
   ** estimate is scaled so that the size of an integer is 1.  */
   if( pszEst ){
     *pszEst = 1;   /* default size is approx 4 bytes */
     if( aff<SQLITE_AFF_NUMERIC ){
       if( zChar ){
         while( zChar[0] ){
           if( sqlite3Isdigit(zChar[0]) ){
             int v = 0;
             sqlite3GetInt32(zChar, &v);
             v = v/4 + 1;
             if( v>255 ) v = 255;
             *pszEst = v; /* BLOB(k), VARCHAR(k), CHAR(k) -> r=(k/4+1) */
             break;
           }
           zChar++;
         }
       }else{
         *pszEst = 5;   /* BLOB, TEXT, CLOB -> r=5  (approx 20 bytes)*/
       }
     }
   }
   return aff;
 }

Here is the call graph for this function:

SQLITE_PRIVATE Index * sqlite3AllocateIndexObject	(	sqlite3 *	db,
		i16	nCol,
		int	nExtra,
		char **	ppExtra
	)

Definition at line 93597 of file sqlite3.c.

References Index::aiColumn, Index::aiRowLogEst, Index::aSortOrder, Index::azColl, Index::nColumn, and Index::nKeyCol.

Referenced by sqlite3CreateIndex().

  {
   Index *p;            /* Allocated index object */
   int nByte;           /* Bytes of space for Index object + arrays */
 
   nByte = ROUND8(sizeof(Index)) +              /* Index structure  */
           ROUND8(sizeof(char*)*nCol) +         /* Index.azColl     */
           ROUND8(sizeof(LogEst)*(nCol+1) +     /* Index.aiRowLogEst   */
                  sizeof(i16)*nCol +            /* Index.aiColumn   */
                  sizeof(u8)*nCol);             /* Index.aSortOrder */
   p = sqlite3DbMallocZero(db, nByte + nExtra);
   if( p ){
     char *pExtra = ((char*)p)+ROUND8(sizeof(Index));
     p->azColl = (char**)pExtra;       pExtra += ROUND8(sizeof(char*)*nCol);
     p->aiRowLogEst = (LogEst*)pExtra; pExtra += sizeof(LogEst)*(nCol+1);
     p->aiColumn = (i16*)pExtra;       pExtra += sizeof(i16)*nCol;
     p->aSortOrder = (u8*)pExtra;
     p->nColumn = nCol;
     p->nKeyCol = nCol - 1;
     *ppExtra = ((char*)p) + nByte;
   }
   return p;
 }

SQLITE_PRIVATE void sqlite3AlterBeginAddColumn	(	Parse *	pParse,
		SrcList *	pSrc
	)

Definition at line 87987 of file sqlite3.c.

References Table::aCol, sqlite3::aDb, Table::addColOffset, Parse::db, sqlite3::mallocFailed, Table::nCol, Table::nRef, Column::pDflt, Parse::pNewTable, Db::pSchema, Table::pSchema, Table::pSelect, sqlite3BeginWriteOperation(), sqlite3ChangeCookie(), sqlite3DbMallocZero(), sqlite3DbStrDup(), sqlite3ErrorMsg(), sqlite3GetVdbe(), sqlite3MPrintf(), sqlite3SchemaToIndex(), sqlite3SrcListDelete(), Column::zColl, Column::zDflt, Column::zName, Table::zName, and Column::zType.

                                                                             {
   Table *pNew;
   Table *pTab;
   Vdbe *v;
   int iDb;
   int i;
   int nAlloc;
   sqlite3 *db = pParse->db;
 
   /* Look up the table being altered. */
   assert( pParse->pNewTable==0 );
   assert( sqlite3BtreeHoldsAllMutexes(db) );
   if( db->mallocFailed ) goto exit_begin_add_column;
   pTab = sqlite3LocateTableItem(pParse, 0, &pSrc->a[0]);
   if( !pTab ) goto exit_begin_add_column;
 
 #ifndef SQLITE_OMIT_VIRTUALTABLE
   if( IsVirtual(pTab) ){
     sqlite3ErrorMsg(pParse, "virtual tables may not be altered");
     goto exit_begin_add_column;
   }
 #endif
 
   /* Make sure this is not an attempt to ALTER a view. */
   if( pTab->pSelect ){
     sqlite3ErrorMsg(pParse, "Cannot add a column to a view");
     goto exit_begin_add_column;
   }
   if( SQLITE_OK!=isSystemTable(pParse, pTab->zName) ){
     goto exit_begin_add_column;
   }
 
   assert( pTab->addColOffset>0 );
   iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
 
   /* Put a copy of the Table struct in Parse.pNewTable for the
   ** sqlite3AddColumn() function and friends to modify.  But modify
   ** the name by adding an "sqlite_altertab_" prefix.  By adding this
   ** prefix, we insure that the name will not collide with an existing
   ** table because user table are not allowed to have the "sqlite_"
   ** prefix on their name.
   */
   pNew = (Table*)sqlite3DbMallocZero(db, sizeof(Table));
   if( !pNew ) goto exit_begin_add_column;
   pParse->pNewTable = pNew;
   pNew->nRef = 1;
   pNew->nCol = pTab->nCol;
   assert( pNew->nCol>0 );
   nAlloc = (((pNew->nCol-1)/8)*8)+8;
   assert( nAlloc>=pNew->nCol && nAlloc%8==0 && nAlloc-pNew->nCol<8 );
   pNew->aCol = (Column*)sqlite3DbMallocZero(db, sizeof(Column)*nAlloc);
   pNew->zName = sqlite3MPrintf(db, "sqlite_altertab_%s", pTab->zName);
   if( !pNew->aCol || !pNew->zName ){
     db->mallocFailed = 1;
     goto exit_begin_add_column;
   }
   memcpy(pNew->aCol, pTab->aCol, sizeof(Column)*pNew->nCol);
   for(i=0; i<pNew->nCol; i++){
     Column *pCol = &pNew->aCol[i];
     pCol->zName = sqlite3DbStrDup(db, pCol->zName);
     pCol->zColl = 0;
     pCol->zType = 0;
     pCol->pDflt = 0;
     pCol->zDflt = 0;
   }
   pNew->pSchema = db->aDb[iDb].pSchema;
   pNew->addColOffset = pTab->addColOffset;
   pNew->nRef = 1;
 
   /* Begin a transaction and increment the schema cookie.  */
   sqlite3BeginWriteOperation(pParse, 0, iDb);
   v = sqlite3GetVdbe(pParse);
   if( !v ) goto exit_begin_add_column;
   sqlite3ChangeCookie(pParse, iDb);
 
 exit_begin_add_column:
   sqlite3SrcListDelete(db, pSrc);
   return;
 }

Here is the call graph for this function:

SQLITE_PRIVATE void sqlite3AlterFinishAddColumn	(	Parse *	pParse,
		Token *	pColDef
	)

Definition at line 87860 of file sqlite3.c.

References Table::aCol, sqlite3::aDb, Table::addColOffset, Column::colFlags, Parse::db, sqlite3::flags, sqlite3::mallocFailed, Token::n, Table::nCol, Parse::nErr, Column::notNull, Expr::op, Column::pDflt, Table::pFKey, Table::pIndex, Parse::pNewTable, Table::pSchema, sqlite3AuthCheck(), sqlite3DbFree(), sqlite3DbStrNDup(), sqlite3ErrorMsg(), sqlite3FindTable(), sqlite3MinimumFileFormat(), sqlite3NestedParse(), sqlite3SchemaToIndex(), sqlite3ValueFree(), sqlite3ValueFromExpr(), Token::z, Db::zName, and Table::zName.

                                                                               {
   Table *pNew;              /* Copy of pParse->pNewTable */
   Table *pTab;              /* Table being altered */
   int iDb;                  /* Database number */
   const char *zDb;          /* Database name */
   const char *zTab;         /* Table name */
   char *zCol;               /* Null-terminated column definition */
   Column *pCol;             /* The new column */
   Expr *pDflt;              /* Default value for the new column */
   sqlite3 *db;              /* The database connection; */
 
   db = pParse->db;
   if( pParse->nErr || db->mallocFailed ) return;
   pNew = pParse->pNewTable;
   assert( pNew );
 
   assert( sqlite3BtreeHoldsAllMutexes(db) );
   iDb = sqlite3SchemaToIndex(db, pNew->pSchema);
   zDb = db->aDb[iDb].zName;
   zTab = &pNew->zName[16];  /* Skip the "sqlite_altertab_" prefix on the name */
   pCol = &pNew->aCol[pNew->nCol-1];
   pDflt = pCol->pDflt;
   pTab = sqlite3FindTable(db, zTab, zDb);
   assert( pTab );
 
 #ifndef SQLITE_OMIT_AUTHORIZATION
   /* Invoke the authorization callback. */
   if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){
     return;
   }
 #endif
 
   /* If the default value for the new column was specified with a 
   ** literal NULL, then set pDflt to 0. This simplifies checking
   ** for an SQL NULL default below.
   */
   if( pDflt && pDflt->op==TK_NULL ){
     pDflt = 0;
   }
 
   /* Check that the new column is not specified as PRIMARY KEY or UNIQUE.
   ** If there is a NOT NULL constraint, then the default value for the
   ** column must not be NULL.
   */
   if( pCol->colFlags & COLFLAG_PRIMKEY ){
     sqlite3ErrorMsg(pParse, "Cannot add a PRIMARY KEY column");
     return;
   }
   if( pNew->pIndex ){
     sqlite3ErrorMsg(pParse, "Cannot add a UNIQUE column");
     return;
   }
   if( (db->flags&SQLITE_ForeignKeys) && pNew->pFKey && pDflt ){
     sqlite3ErrorMsg(pParse, 
         "Cannot add a REFERENCES column with non-NULL default value");
     return;
   }
   if( pCol->notNull && !pDflt ){
     sqlite3ErrorMsg(pParse, 
         "Cannot add a NOT NULL column with default value NULL");
     return;
   }
 
   /* Ensure the default expression is something that sqlite3ValueFromExpr()
   ** can handle (i.e. not CURRENT_TIME etc.)
   */
   if( pDflt ){
     sqlite3_value *pVal = 0;
     int rc;
     rc = sqlite3ValueFromExpr(db, pDflt, SQLITE_UTF8, SQLITE_AFF_NONE, &pVal);
     assert( rc==SQLITE_OK || rc==SQLITE_NOMEM );
     if( rc!=SQLITE_OK ){
       db->mallocFailed = 1;
       return;
     }
     if( !pVal ){
       sqlite3ErrorMsg(pParse, "Cannot add a column with non-constant default");
       return;
     }
     sqlite3ValueFree(pVal);
   }
 
   /* Modify the CREATE TABLE statement. */
   zCol = sqlite3DbStrNDup(db, (char*)pColDef->z, pColDef->n);
   if( zCol ){
     char *zEnd = &zCol[pColDef->n-1];
     int savedDbFlags = db->flags;
     while( zEnd>zCol && (*zEnd==';' || sqlite3Isspace(*zEnd)) ){
       *zEnd-- = '\0';
     }
     db->flags |= SQLITE_PreferBuiltin;
     sqlite3NestedParse(pParse, 
         "UPDATE \"%w\".%s SET "
           "sql = substr(sql,1,%d) || ', ' || %Q || substr(sql,%d) "
         "WHERE type = 'table' AND name = %Q", 
       zDb, SCHEMA_TABLE(iDb), pNew->addColOffset, zCol, pNew->addColOffset+1,
       zTab
     );
     sqlite3DbFree(db, zCol);
     db->flags = savedDbFlags;
   }
 
   /* If the default value of the new column is NULL, then set the file
   ** format to 2. If the default value of the new column is not NULL,
   ** the file format becomes 3.
   */
   sqlite3MinimumFileFormat(pParse, iDb, pDflt ? 3 : 2);
 
   /* Reload the schema of the modified table. */
   reloadTableSchema(pParse, pTab, pTab->zName);
 }

Here is the call graph for this function:

SQLITE_PRIVATE void sqlite3AlterFunctions ( void )

Definition at line 87465 of file sqlite3.c.

References sqlite3FuncDefInsert(), and sqlite3GlobalFunctions.

Referenced by sqlite3RegisterGlobalFunctions().

                                                {
   static SQLITE_WSD FuncDef aAlterTableFuncs[] = {
     FUNCTION(sqlite_rename_table,   2, 0, 0, renameTableFunc),
 #ifndef SQLITE_OMIT_TRIGGER
     FUNCTION(sqlite_rename_trigger, 2, 0, 0, renameTriggerFunc),
 #endif
 #ifndef SQLITE_OMIT_FOREIGN_KEY
     FUNCTION(sqlite_rename_parent,  3, 0, 0, renameParentFunc),
 #endif
   };
   int i;
   FuncDefHash *pHash = &GLOBAL(FuncDefHash, sqlite3GlobalFunctions);
   FuncDef *aFunc = (FuncDef*)&GLOBAL(FuncDef, aAlterTableFuncs);
 
   for(i=0; i<ArraySize(aAlterTableFuncs); i++){
     sqlite3FuncDefInsert(pHash, &aFunc[i]);
   }
 }

Here is the call graph for this function:

SQLITE_PRIVATE void sqlite3AlterRenameTable	(	Parse *	pParse,
		SrcList *	pSrc,
		Token *	pName
	)

Definition at line 87629 of file sqlite3.c.

References sqlite3::aDb, Parse::db, sqlite3::flags, sqlite3::mallocFailed, Parse::nMem, FKey::pFrom, sqlite3_vtab::pModule, FKey::pNextTo, Table::pSchema, Table::pSelect, VTable::pVtab, sqlite3AuthCheck(), sqlite3BeginWriteOperation(), sqlite3ChangeCookie(), sqlite3CheckObjectName(), sqlite3DbFree(), sqlite3ErrorMsg(), sqlite3FindIndex(), sqlite3FindTable(), sqlite3FkReferences(), sqlite3GetVdbe(), sqlite3GetVTable(), sqlite3MayAbort(), sqlite3NameFromToken(), sqlite3NestedParse(), sqlite3SchemaToIndex(), sqlite3SrcListDelete(), sqlite3Utf8CharLen(), sqlite3VdbeAddOp4(), sqlite3ViewGetColumnNames(), sqlite3_module::xRename, Db::zName, and Table::zName.

  {
   int iDb;                  /* Database that contains the table */
   char *zDb;                /* Name of database iDb */
   Table *pTab;              /* Table being renamed */
   char *zName = 0;          /* NULL-terminated version of pName */ 
   sqlite3 *db = pParse->db; /* Database connection */
   int nTabName;             /* Number of UTF-8 characters in zTabName */
   const char *zTabName;     /* Original name of the table */
   Vdbe *v;
 #ifndef SQLITE_OMIT_TRIGGER
   char *zWhere = 0;         /* Where clause to locate temp triggers */
 #endif
   VTable *pVTab = 0;        /* Non-zero if this is a v-tab with an xRename() */
   int savedDbFlags;         /* Saved value of db->flags */
 
   savedDbFlags = db->flags;  
   if( NEVER(db->mallocFailed) ) goto exit_rename_table;
   assert( pSrc->nSrc==1 );
   assert( sqlite3BtreeHoldsAllMutexes(pParse->db) );
 
   pTab = sqlite3LocateTableItem(pParse, 0, &pSrc->a[0]);
   if( !pTab ) goto exit_rename_table;
   iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
   zDb = db->aDb[iDb].zName;
   db->flags |= SQLITE_PreferBuiltin;
 
   /* Get a NULL terminated version of the new table name. */
   zName = sqlite3NameFromToken(db, pName);
   if( !zName ) goto exit_rename_table;
 
   /* Check that a table or index named 'zName' does not already exist
   ** in database iDb. If so, this is an error.
   */
   if( sqlite3FindTable(db, zName, zDb) || sqlite3FindIndex(db, zName, zDb) ){
     sqlite3ErrorMsg(pParse, 
         "there is already another table or index with this name: %s", zName);
     goto exit_rename_table;
   }
 
   /* Make sure it is not a system table being altered, or a reserved name
   ** that the table is being renamed to.
   */
   if( SQLITE_OK!=isSystemTable(pParse, pTab->zName) ){
     goto exit_rename_table;
   }
   if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){ goto
     exit_rename_table;
   }
 
 #ifndef SQLITE_OMIT_VIEW
   if( pTab->pSelect ){
     sqlite3ErrorMsg(pParse, "view %s may not be altered", pTab->zName);
     goto exit_rename_table;
   }
 #endif
 
 #ifndef SQLITE_OMIT_AUTHORIZATION
   /* Invoke the authorization callback. */
   if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){
     goto exit_rename_table;
   }
 #endif
 
 #ifndef SQLITE_OMIT_VIRTUALTABLE
   if( sqlite3ViewGetColumnNames(pParse, pTab) ){
     goto exit_rename_table;
   }
   if( IsVirtual(pTab) ){
     pVTab = sqlite3GetVTable(db, pTab);
     if( pVTab->pVtab->pModule->xRename==0 ){
       pVTab = 0;
     }
   }
 #endif
 
   /* Begin a transaction for database iDb. 
   ** Then modify the schema cookie (since the ALTER TABLE modifies the
   ** schema). Open a statement transaction if the table is a virtual
   ** table.
   */
   v = sqlite3GetVdbe(pParse);
   if( v==0 ){
     goto exit_rename_table;
   }
   sqlite3BeginWriteOperation(pParse, pVTab!=0, iDb);
   sqlite3ChangeCookie(pParse, iDb);
 
   /* If this is a virtual table, invoke the xRename() function if
   ** one is defined. The xRename() callback will modify the names
   ** of any resources used by the v-table implementation (including other
   ** SQLite tables) that are identified by the name of the virtual table.
   */
 #ifndef SQLITE_OMIT_VIRTUALTABLE
   if( pVTab ){
     int i = ++pParse->nMem;
     sqlite3VdbeAddOp4(v, OP_String8, 0, i, 0, zName, 0);
     sqlite3VdbeAddOp4(v, OP_VRename, i, 0, 0,(const char*)pVTab, P4_VTAB);
     sqlite3MayAbort(pParse);
   }
 #endif
 
   /* figure out how many UTF-8 characters are in zName */
   zTabName = pTab->zName;
   nTabName = sqlite3Utf8CharLen(zTabName, -1);
 
 #if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER)
   if( db->flags&SQLITE_ForeignKeys ){
     /* If foreign-key support is enabled, rewrite the CREATE TABLE 
     ** statements corresponding to all child tables of foreign key constraints
     ** for which the renamed table is the parent table.  */
     if( (zWhere=whereForeignKeys(pParse, pTab))!=0 ){
       sqlite3NestedParse(pParse, 
           "UPDATE \"%w\".%s SET "
               "sql = sqlite_rename_parent(sql, %Q, %Q) "
               "WHERE %s;", zDb, SCHEMA_TABLE(iDb), zTabName, zName, zWhere);
       sqlite3DbFree(db, zWhere);
     }
   }
 #endif
 
   /* Modify the sqlite_master table to use the new table name. */
   sqlite3NestedParse(pParse,
       "UPDATE %Q.%s SET "
 #ifdef SQLITE_OMIT_TRIGGER
           "sql = sqlite_rename_table(sql, %Q), "
 #else
           "sql = CASE "
             "WHEN type = 'trigger' THEN sqlite_rename_trigger(sql, %Q)"
             "ELSE sqlite_rename_table(sql, %Q) END, "
 #endif
           "tbl_name = %Q, "
           "name = CASE "
             "WHEN type='table' THEN %Q "
             "WHEN name LIKE 'sqlite_autoindex%%' AND type='index' THEN "
              "'sqlite_autoindex_' || %Q || substr(name,%d+18) "
             "ELSE name END "
       "WHERE tbl_name=%Q COLLATE nocase AND "
           "(type='table' OR type='index' OR type='trigger');", 
       zDb, SCHEMA_TABLE(iDb), zName, zName, zName, 
 #ifndef SQLITE_OMIT_TRIGGER
       zName,
 #endif
       zName, nTabName, zTabName
   );
 
 #ifndef SQLITE_OMIT_AUTOINCREMENT
   /* If the sqlite_sequence table exists in this database, then update 
   ** it with the new table name.
   */
   if( sqlite3FindTable(db, "sqlite_sequence", zDb) ){
     sqlite3NestedParse(pParse,
         "UPDATE \"%w\".sqlite_sequence set name = %Q WHERE name = %Q",
         zDb, zName, pTab->zName);
   }
 #endif
 
 #ifndef SQLITE_OMIT_TRIGGER
   /* If there are TEMP triggers on this table, modify the sqlite_temp_master
   ** table. Don't do this if the table being ALTERed is itself located in
   ** the temp database.
   */
   if( (zWhere=whereTempTriggers(pParse, pTab))!=0 ){
     sqlite3NestedParse(pParse, 
         "UPDATE sqlite_temp_master SET "
             "sql = sqlite_rename_trigger(sql, %Q), "
             "tbl_name = %Q "
             "WHERE %s;", zName, zName, zWhere);
     sqlite3DbFree(db, zWhere);
   }
 #endif
 
 #if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER)
   if( db->flags&SQLITE_ForeignKeys ){
     FKey *p;
     for(p=sqlite3FkReferences(pTab); p; p=p->pNextTo){
       Table *pFrom = p->pFrom;
       if( pFrom!=pTab ){
         reloadTableSchema(pParse, p->pFrom, pFrom->zName);
       }
     }
   }
 #endif
 
   /* Drop and reload the internal table schema. */
   reloadTableSchema(pParse, pTab, zName);
 
 exit_rename_table:
   sqlite3SrcListDelete(db, pSrc);
   sqlite3DbFree(db, zName);
   db->flags = savedDbFlags;
 }

Here is the call graph for this function:

SQLITE_PRIVATE int sqlite3AnalysisLoad	(	sqlite3 *	db,
		int	iDB
	)

Definition at line 89900 of file sqlite3.c.

References sqlite3::aDb, analysisInfo::db, Schema::idxHash, sqlite3::mallocFailed, Db::pSchema, sqlite3_exec(), sqlite3DbFree(), sqlite3FindTable(), sqlite3MPrintf(), analysisInfo::zDatabase, and Db::zName.

Referenced by sqlite3VdbeExec().

                                                             {
   analysisInfo sInfo;
   HashElem *i;
   char *zSql;
   int rc;
 
   assert( iDb>=0 && iDb<db->nDb );
   assert( db->aDb[iDb].pBt!=0 );
 
   /* Clear any prior statistics */
   assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
   for(i=sqliteHashFirst(&db->aDb[iDb].pSchema->idxHash);i;i=sqliteHashNext(i)){
     Index *pIdx = sqliteHashData(i);
     sqlite3DefaultRowEst(pIdx);
 #ifdef SQLITE_ENABLE_STAT3_OR_STAT4
     sqlite3DeleteIndexSamples(db, pIdx);
     pIdx->aSample = 0;
 #endif
   }
 
   /* Check to make sure the sqlite_stat1 table exists */
   sInfo.db = db;
   sInfo.zDatabase = db->aDb[iDb].zName;
   if( sqlite3FindTable(db, "sqlite_stat1", sInfo.zDatabase)==0 ){
     return SQLITE_ERROR;
   }
 
   /* Load new statistics out of the sqlite_stat1 table */
   zSql = sqlite3MPrintf(db, 
       "SELECT tbl,idx,stat FROM %Q.sqlite_stat1", sInfo.zDatabase);
   if( zSql==0 ){
     rc = SQLITE_NOMEM;
   }else{
     rc = sqlite3_exec(db, zSql, analysisLoader, &sInfo, 0);
     sqlite3DbFree(db, zSql);
   }
 
 
   /* Load the statistics from the sqlite_stat4 table. */
 #ifdef SQLITE_ENABLE_STAT3_OR_STAT4
   if( rc==SQLITE_OK && OptimizationEnabled(db, SQLITE_Stat34) ){
     int lookasideEnabled = db->lookaside.bEnabled;
     db->lookaside.bEnabled = 0;
     rc = loadStat4(db, sInfo.zDatabase);
     db->lookaside.bEnabled = lookasideEnabled;
   }
   for(i=sqliteHashFirst(&db->aDb[iDb].pSchema->idxHash);i;i=sqliteHashNext(i)){
     Index *pIdx = sqliteHashData(i);
     sqlite3_free(pIdx->aiRowEst);
     pIdx->aiRowEst = 0;
   }
 #endif
 
   if( rc==SQLITE_NOMEM ){
     db->mallocFailed = 1;
   }
   return rc;
 }

Here is the call graph for this function:

SQLITE_PRIVATE void sqlite3Analyze	(	Parse *	pParse,
		Token *	pName1,
		Token *	pName2
	)

Definition at line 89418 of file sqlite3.c.

References sqlite3::aDb, Parse::db, Token::n, sqlite3::nDb, Index::pTable, sqlite3DbFree(), sqlite3FindDb(), sqlite3FindIndex(), sqlite3GetVdbe(), sqlite3LocateTable(), sqlite3NameFromToken(), sqlite3ReadSchema(), sqlite3TwoPartName(), sqlite3VdbeAddOp0(), and Db::zName.

                                                                                {
   sqlite3 *db = pParse->db;
   int iDb;
   int i;
   char *z, *zDb;
   Table *pTab;
   Index *pIdx;
   Token *pTableName;
   Vdbe *v;
 
   /* Read the database schema. If an error occurs, leave an error message
   ** and code in pParse and return NULL. */
   assert( sqlite3BtreeHoldsAllMutexes(pParse->db) );
   if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
     return;
   }
 
   assert( pName2!=0 || pName1==0 );
   if( pName1==0 ){
     /* Form 1:  Analyze everything */
     for(i=0; i<db->nDb; i++){
       if( i==1 ) continue;  /* Do not analyze the TEMP database */
       analyzeDatabase(pParse, i);
     }
   }else if( pName2->n==0 ){
     /* Form 2:  Analyze the database or table named */
     iDb = sqlite3FindDb(db, pName1);
     if( iDb>=0 ){
       analyzeDatabase(pParse, iDb);
     }else{
       z = sqlite3NameFromToken(db, pName1);
       if( z ){
         if( (pIdx = sqlite3FindIndex(db, z, 0))!=0 ){
           analyzeTable(pParse, pIdx->pTable, pIdx);
         }else if( (pTab = sqlite3LocateTable(pParse, 0, z, 0))!=0 ){
           analyzeTable(pParse, pTab, 0);
         }
         sqlite3DbFree(db, z);
       }
     }
   }else{
     /* Form 3: Analyze the fully qualified table name */
     iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pTableName);
     if( iDb>=0 ){
       zDb = db->aDb[iDb].zName;
       z = sqlite3NameFromToken(db, pTableName);
       if( z ){
         if( (pIdx = sqlite3FindIndex(db, z, zDb))!=0 ){
           analyzeTable(pParse, pIdx->pTable, pIdx);
         }else if( (pTab = sqlite3LocateTable(pParse, 0, z, zDb))!=0 ){
           analyzeTable(pParse, pTab, 0);
         }
         sqlite3DbFree(db, z);
       }
     }   
   }
   v = sqlite3GetVdbe(pParse);
   if( v ) sqlite3VdbeAddOp0(v, OP_Expire);
 }

Here is the call graph for this function:

SQLITE_PRIVATE int sqlite3ApiExit	(	sqlite3 *	db,
		int	rc
	)

Definition at line 21337 of file sqlite3.c.

References sqlite3::errMask, and sqlite3::mallocFailed.

Referenced by sqlite3_blob_open(), sqlite3_blob_reopen(), sqlite3_complete16(), sqlite3_create_collation16(), sqlite3_create_collation_v2(), sqlite3_create_function16(), sqlite3_create_function_v2(), sqlite3_declare_vtab(), sqlite3_exec(), sqlite3_finalize(), sqlite3_load_extension(), sqlite3_open16(), sqlite3_overload_function(), sqlite3_reset(), sqlite3_step(), sqlite3_table_column_metadata(), and sqlite3_wal_checkpoint_v2().

                                                       {
   /* If the db handle is not NULL, then we must hold the connection handle
   ** mutex here. Otherwise the read (and possible write) of db->mallocFailed 
   ** is unsafe, as is the call to sqlite3Error().
   */
   assert( !db || sqlite3_mutex_held(db->mutex) );
   if( db==0 ) return rc & 0xff;
   if( db->mallocFailed || rc==SQLITE_IOERR_NOMEM ){
     return apiOomError(db);
   }
   return rc & db->errMask;
 }

SQLITE_PRIVATE void sqlite3AppendChar	(	StrAccum *	p,
		int	N,
		char	c
	)

Definition at line 22150 of file sqlite3.c.

References StrAccum::nAlloc, StrAccum::nChar, and StrAccum::zText.

Referenced by sqlite3VXPrintf().

                                                                  {
   testcase( p->nChar + (i64)N > 0x7fffffff );
   if( p->nChar+(i64)N >= p->nAlloc && (N = sqlite3StrAccumEnlarge(p, N))<=0 ){
     return;
   }
   while( (N--)>0 ) p->zText[p->nChar++] = c;
 }

SQLITE_PRIVATE void * sqlite3ArrayAllocate	(	sqlite3 *	db,
		void *	pArray,
		int	szEntry,
		int *	pnEntry,
		int *	pIdx
	)

Definition at line 94249 of file sqlite3.c.

References sqlite3DbRealloc().

  {
   char *z;
   int n = *pnEntry;
   if( (n & (n-1))==0 ){
     int sz = (n==0) ? 1 : 2*n;
     void *pNew = sqlite3DbRealloc(db, pArray, sz*szEntry);
     if( pNew==0 ){
       *pIdx = -1;
       return pArray;
     }
     pArray = pNew;
   }
   z = (char*)pArray;
   memset(&z[n * szEntry], 0, szEntry);
   *pIdx = n;
   ++*pnEntry;
   return pArray;
 }

Here is the call graph for this function:

SQLITE_PRIVATE int sqlite3AtoF	(	const char *	z,
		double *	pResult,
		int	length,
		u8	enc
	)

Definition at line 23738 of file sqlite3.c.

Referenced by sqlite3VdbeRealValue().

                                                                                   {
 #ifndef SQLITE_OMIT_FLOATING_POINT
   int incr;
   const char *zEnd = z + length;
   /* sign * significand * (10 ^ (esign * exponent)) */
   int sign = 1;    /* sign of significand */
   i64 s = 0;       /* significand */
   int d = 0;       /* adjust exponent for shifting decimal point */
   int esign = 1;   /* sign of exponent */
   int e = 0;       /* exponent */
   int eValid = 1;  /* True exponent is either not used or is well-formed */
   double result;
   int nDigits = 0;
   int nonNum = 0;
 
   assert( enc==SQLITE_UTF8 || enc==SQLITE_UTF16LE || enc==SQLITE_UTF16BE );
   *pResult = 0.0;   /* Default return value, in case of an error */
 
   if( enc==SQLITE_UTF8 ){
     incr = 1;
   }else{
     int i;
     incr = 2;
     assert( SQLITE_UTF16LE==2 && SQLITE_UTF16BE==3 );
     for(i=3-enc; i<length && z[i]==0; i+=2){}
     nonNum = i<length;
     zEnd = z+i+enc-3;
     z += (enc&1);
   }
 
   /* skip leading spaces */
   while( z<zEnd && sqlite3Isspace(*z) ) z+=incr;
   if( z>=zEnd ) return 0;
 
   /* get sign of significand */
   if( *z=='-' ){
     sign = -1;
     z+=incr;
   }else if( *z=='+' ){
     z+=incr;
   }
 
   /* skip leading zeroes */
   while( z<zEnd && z[0]=='0' ) z+=incr, nDigits++;
 
   /* copy max significant digits to significand */
   while( z<zEnd && sqlite3Isdigit(*z) && s<((LARGEST_INT64-9)/10) ){
     s = s*10 + (*z - '0');
     z+=incr, nDigits++;
   }
 
   /* skip non-significant significand digits
   ** (increase exponent by d to shift decimal left) */
   while( z<zEnd && sqlite3Isdigit(*z) ) z+=incr, nDigits++, d++;
   if( z>=zEnd ) goto do_atof_calc;
 
   /* if decimal point is present */
   if( *z=='.' ){
     z+=incr;
     /* copy digits from after decimal to significand
     ** (decrease exponent by d to shift decimal right) */
     while( z<zEnd && sqlite3Isdigit(*z) && s<((LARGEST_INT64-9)/10) ){
       s = s*10 + (*z - '0');
       z+=incr, nDigits++, d--;
     }
     /* skip non-significant digits */
     while( z<zEnd && sqlite3Isdigit(*z) ) z+=incr, nDigits++;
   }
   if( z>=zEnd ) goto do_atof_calc;
 
   /* if exponent is present */
   if( *z=='e' || *z=='E' ){
     z+=incr;
     eValid = 0;
     if( z>=zEnd ) goto do_atof_calc;
     /* get sign of exponent */
     if( *z=='-' ){
       esign = -1;
       z+=incr;
     }else if( *z=='+' ){
       z+=incr;
     }
     /* copy digits to exponent */
     while( z<zEnd && sqlite3Isdigit(*z) ){
       e = e<10000 ? (e*10 + (*z - '0')) : 10000;
       z+=incr;
       eValid = 1;
     }
   }
 
   /* skip trailing spaces */
   if( nDigits && eValid ){
     while( z<zEnd && sqlite3Isspace(*z) ) z+=incr;
   }
 
 do_atof_calc:
   /* adjust exponent by d, and update sign */
   e = (e*esign) + d;
   if( e<0 ) {
     esign = -1;
     e *= -1;
   } else {
     esign = 1;
   }
 
   /* if 0 significand */
   if( !s ) {
     /* In the IEEE 754 standard, zero is signed.
     ** Add the sign if we've seen at least one digit */
     result = (sign<0 && nDigits) ? -(double)0 : (double)0;
   } else {
     /* attempt to reduce exponent */
     if( esign>0 ){
       while( s<(LARGEST_INT64/10) && e>0 ) e--,s*=10;
     }else{
       while( !(s%10) && e>0 ) e--,s/=10;
     }
 
     /* adjust the sign of significand */
     s = sign<0 ? -s : s;
 
     /* if exponent, scale significand as appropriate
     ** and store in result. */
     if( e ){
       LONGDOUBLE_TYPE scale = 1.0;
       /* attempt to handle extremely small/large numbers better */
       if( e>307 && e<342 ){
         while( e%308 ) { scale *= 1.0e+1; e -= 1; }
         if( esign<0 ){
           result = s / scale;
           result /= 1.0e+308;
         }else{
           result = s * scale;
           result *= 1.0e+308;
         }
       }else if( e>=342 ){
         if( esign<0 ){
           result = 0.0*s;
         }else{
           result = 1e308*1e308*s;  /* Infinity */
         }
       }else{
         /* 1.0e+22 is the largest power of 10 than can be 
         ** represented exactly. */
         while( e%22 ) { scale *= 1.0e+1; e -= 1; }
         while( e>0 ) { scale *= 1.0e+22; e -= 22; }
         if( esign<0 ){
           result = s / scale;
         }else{
           result = s * scale;
         }
       }
     } else {
       result = (double)s;
     }
   }
 
   /* store the result */
   *pResult = result;
 
   /* return true if number and no extra non-whitespace chracters after */
   return z>=zEnd && nDigits>0 && eValid && nonNum==0;
 #else
   return !sqlite3Atoi64(z, pResult, length, enc);
 #endif /* SQLITE_OMIT_FLOATING_POINT */
 }

SQLITE_PRIVATE int sqlite3Atoi ( const char * z )

Definition at line 24126 of file sqlite3.c.

References sqlite3GetInt32().

Referenced by sqlite3InitCallback(), and sqlite3Pragma().

                                              {
   int x = 0;
   if( z ) sqlite3GetInt32(z, &x);
   return x;
 }

Here is the call graph for this function:

SQLITE_PRIVATE int sqlite3Atoi64	(	const char *	zNum,
		i64 *	pNum,
		int	length,
		u8	enc
	)

Definition at line 23955 of file sqlite3.c.

Referenced by sqlite3DecOrHexToI64(), sqlite3ExprAssignVarNumber(), sqlite3VdbeIntValue(), and sqlite3VdbeMemNumerify().

                                                                                  {
   int incr;
   u64 u = 0;
   int neg = 0; /* assume positive */
   int i;
   int c = 0;
   int nonNum = 0;
   const char *zStart;
   const char *zEnd = zNum + length;
   assert( enc==SQLITE_UTF8 || enc==SQLITE_UTF16LE || enc==SQLITE_UTF16BE );
   if( enc==SQLITE_UTF8 ){
     incr = 1;
   }else{
     incr = 2;
     assert( SQLITE_UTF16LE==2 && SQLITE_UTF16BE==3 );
     for(i=3-enc; i<length && zNum[i]==0; i+=2){}
     nonNum = i<length;
     zEnd = zNum+i+enc-3;
     zNum += (enc&1);
   }
   while( zNum<zEnd && sqlite3Isspace(*zNum) ) zNum+=incr;
   if( zNum<zEnd ){
     if( *zNum=='-' ){
       neg = 1;
       zNum+=incr;
     }else if( *zNum=='+' ){
       zNum+=incr;
     }
   }
   zStart = zNum;
   while( zNum<zEnd && zNum[0]=='0' ){ zNum+=incr; } /* Skip leading zeros. */
   for(i=0; &zNum[i]<zEnd && (c=zNum[i])>='0' && c<='9'; i+=incr){
     u = u*10 + c - '0';
   }
   if( u>LARGEST_INT64 ){
     *pNum = neg ? SMALLEST_INT64 : LARGEST_INT64;
   }else if( neg ){
     *pNum = -(i64)u;
   }else{
     *pNum = (i64)u;
   }
   testcase( i==18 );
   testcase( i==19 );
   testcase( i==20 );
   if( (c!=0 && &zNum[i]<zEnd) || (i==0 && zStart==zNum) || i>19*incr || nonNum ){
     /* zNum is empty or contains non-numeric text or is longer
     ** than 19 digits (thus guaranteeing that it is too large) */
     return 1;
   }else if( i<19*incr ){
     /* Less than 19 digits, so we know that it fits in 64 bits */
     assert( u<=LARGEST_INT64 );
     return 0;
   }else{
     /* zNum is a 19-digit numbers.  Compare it against 9223372036854775808. */
     c = compare2pow63(zNum, incr);
     if( c<0 ){
       /* zNum is less than 9223372036854775808 so it fits */
       assert( u<=LARGEST_INT64 );
       return 0;
     }else if( c>0 ){
       /* zNum is greater than 9223372036854775808 so it overflows */
       return 1;
     }else{
       /* zNum is exactly 9223372036854775808.  Fits if negative.  The
       ** special case 2 overflow if positive */
       assert( u-1==LARGEST_INT64 );
       return neg ? 0 : 2;
     }
   }
 }

SQLITE_PRIVATE void sqlite3Attach	(	Parse *	pParse,
		Expr *	p,
		Expr *	pDbname,
		Expr *	pKey
	)

Definition at line 90368 of file sqlite3.c.

                                                                                     {
   static const FuncDef attach_func = {
     3,                /* nArg */
     SQLITE_UTF8,      /* funcFlags */
     0,                /* pUserData */
     0,                /* pNext */
     attachFunc,       /* xFunc */
     0,                /* xStep */
     0,                /* xFinalize */
     "sqlite_attach",  /* zName */
     0,                /* pHash */
     0                 /* pDestructor */
   };
   codeAttach(pParse, SQLITE_ATTACH, &attach_func, p, p, pDbname, pKey);
 }

SQLITE_PRIVATE int sqlite3AuthCheck	(	Parse *	pParse,
		int	code,
		const char *	zArg1,
		const char *	zArg2,
		const char *	zArg3
	)

Definition at line 90746 of file sqlite3.c.

References sqlite3::sqlite3InitInfo::busy, Parse::db, sqlite3::pAuthArg, Parse::rc, sqlite3ErrorMsg(), sqlite3::xAuth, and Parse::zAuthContext.

Referenced by sqlite3AlterFinishAddColumn(), sqlite3AlterRenameTable(), sqlite3BeginTransaction(), sqlite3BeginTrigger(), sqlite3CommitTransaction(), sqlite3CreateIndex(), sqlite3DeleteFrom(), sqlite3DropIndex(), sqlite3DropTable(), sqlite3DropTriggerPtr(), sqlite3Insert(), sqlite3Pragma(), sqlite3RollbackTransaction(), sqlite3Savepoint(), sqlite3Select(), sqlite3StartTable(), sqlite3Update(), and sqlite3VtabBeginParse().

  {
   sqlite3 *db = pParse->db;
   int rc;
 
   /* Don't do any authorization checks if the database is initialising
   ** or if the parser is being invoked from within sqlite3_declare_vtab.
   */
   if( db->init.busy || IN_DECLARE_VTAB ){
     return SQLITE_OK;
   }
 
   if( db->xAuth==0 ){
     return SQLITE_OK;
   }
   rc = db->xAuth(db->pAuthArg, code, zArg1, zArg2, zArg3, pParse->zAuthContext
 #ifdef SQLITE_USER_AUTHENTICATION
                  ,db->auth.zAuthUser
 #endif
                 );
   if( rc==SQLITE_DENY ){
     sqlite3ErrorMsg(pParse, "not authorized");
     pParse->rc = SQLITE_AUTH;
   }else if( rc!=SQLITE_OK && rc!=SQLITE_IGNORE ){
     rc = SQLITE_DENY;
     sqliteAuthBadReturnCode(pParse);
   }
   return rc;
 }

Here is the call graph for this function:

SQLITE_PRIVATE void sqlite3AuthContextPop ( AuthContext * pContext )

Definition at line 90801 of file sqlite3.c.

References AuthContext::pParse, Parse::zAuthContext, and AuthContext::zAuthContext.

Referenced by sqlite3DeleteFrom(), and sqlite3Update().

                                                                 {
   if( pContext->pParse ){
     pContext->pParse->zAuthContext = pContext->zAuthContext;
     pContext->pParse = 0;
   }
 }

SQLITE_PRIVATE void sqlite3AuthContextPush	(	Parse *	pParse,
		AuthContext *	pContext,
		const char *	zContext
	)

Definition at line 90786 of file sqlite3.c.

References AuthContext::pParse, Parse::zAuthContext, and AuthContext::zAuthContext.

Referenced by sqlite3DeleteFrom(), and sqlite3Update().

  {
   assert( pParse );
   pContext->pParse = pParse;
   pContext->zAuthContext = pParse->zAuthContext;
   pParse->zAuthContext = zContext;
 }

SQLITE_PRIVATE void sqlite3AuthRead	(	Parse *	pParse,
		Expr *	pExpr,
		Schema *	pSchema,
		SrcList *	pTabList
	)

Definition at line 90689 of file sqlite3.c.

References Table::aCol, Parse::db, Expr::iColumn, SrcList::SrcList_item::iCursor, Table::iPKey, Expr::iTable, SrcList::nSrc, Expr::op, SrcList::SrcList_item::pTab, Parse::pTriggerTab, sqlite3AuthReadCol(), sqlite3SchemaToIndex(), sqlite3::xAuth, Column::zName, and Table::zName.

  {
   sqlite3 *db = pParse->db;
   Table *pTab = 0;      /* The table being read */
   const char *zCol;     /* Name of the column of the table */
   int iSrc;             /* Index in pTabList->a[] of table being read */
   int iDb;              /* The index of the database the expression refers to */
   int iCol;             /* Index of column in table */
 
   if( db->xAuth==0 ) return;
   iDb = sqlite3SchemaToIndex(pParse->db, pSchema);
   if( iDb<0 ){
     /* An attempt to read a column out of a subquery or other
     ** temporary table. */
     return;
   }
 
   assert( pExpr->op==TK_COLUMN || pExpr->op==TK_TRIGGER );
   if( pExpr->op==TK_TRIGGER ){
     pTab = pParse->pTriggerTab;
   }else{
     assert( pTabList );
     for(iSrc=0; ALWAYS(iSrc<pTabList->nSrc); iSrc++){
       if( pExpr->iTable==pTabList->a[iSrc].iCursor ){
         pTab = pTabList->a[iSrc].pTab;
         break;
       }
     }
   }
   iCol = pExpr->iColumn;
   if( NEVER(pTab==0) ) return;
 
   if( iCol>=0 ){
     assert( iCol<pTab->nCol );
     zCol = pTab->aCol[iCol].zName;
   }else if( pTab->iPKey>=0 ){
     assert( pTab->iPKey<pTab->nCol );
     zCol = pTab->aCol[pTab->iPKey].zName;
   }else{
     zCol = "ROWID";
   }
   assert( iDb>=0 && iDb<db->nDb );
   if( SQLITE_IGNORE==sqlite3AuthReadCol(pParse, pTab->zName, zCol, iDb) ){
     pExpr->op = TK_NULL;
   }
 }

Here is the call graph for this function:

SQLITE_PRIVATE int sqlite3AuthReadCol	(	Parse *	pParse,
		const char *	zTab,
		const char *	zCol,
		int	iDb
	)

Definition at line 90652 of file sqlite3.c.

References sqlite3::aDb, Parse::db, sqlite3::nDb, sqlite3::pAuthArg, Parse::rc, sqlite3ErrorMsg(), sqlite3::xAuth, Parse::zAuthContext, and Db::zName.

Referenced by sqlite3AuthRead(), and sqlite3FkCheck().

  {
   sqlite3 *db = pParse->db;       /* Database handle */
   char *zDb = db->aDb[iDb].zName; /* Name of attached database */
   int rc;                         /* Auth callback return code */
 
   rc = db->xAuth(db->pAuthArg, SQLITE_READ, zTab,zCol,zDb,pParse->zAuthContext
 #ifdef SQLITE_USER_AUTHENTICATION
                  ,db->auth.zAuthUser
 #endif
                 );
   if( rc==SQLITE_DENY ){
     if( db->nDb>2 || iDb!=0 ){
       sqlite3ErrorMsg(pParse, "access to %s.%s.%s is prohibited",zDb,zTab,zCol);
     }else{
       sqlite3ErrorMsg(pParse, "access to %s.%s is prohibited", zTab, zCol);
     }
     pParse->rc = SQLITE_AUTH;
   }else if( rc!=SQLITE_IGNORE && rc!=SQLITE_OK ){
     sqliteAuthBadReturnCode(pParse);
   }
   return rc;
 }

Here is the call graph for this function:

SQLITE_PRIVATE void sqlite3AutoincrementBegin ( Parse * pParse )

Definition at line 99881 of file sqlite3.c.

References sqlite3::aDb, Parse::db, AutoincInfo::iDb, Parse::pAinc, AutoincInfo::pNext, Db::pSchema, Schema::pSeqTab, AutoincInfo::pTab, Parse::pVdbe, AutoincInfo::regCtr, sqlite3OpenTable(), sqlite3VdbeAddOp0(), sqlite3VdbeAddOp2(), sqlite3VdbeAddOp3(), sqlite3VdbeAddOp4(), sqlite3VdbeChangeP5(), sqlite3VdbeCurrentAddr(), and Table::zName.

Referenced by sqlite3FinishCoding().

                                                             {
   AutoincInfo *p;            /* Information about an AUTOINCREMENT */
   sqlite3 *db = pParse->db;  /* The database connection */
   Db *pDb;                   /* Database only autoinc table */
   int memId;                 /* Register holding max rowid */
   int addr;                  /* A VDBE address */
   Vdbe *v = pParse->pVdbe;   /* VDBE under construction */
 
   /* This routine is never called during trigger-generation.  It is
   ** only called from the top-level */
   assert( pParse->pTriggerTab==0 );
   assert( pParse==sqlite3ParseToplevel(pParse) );
 
   assert( v );   /* We failed long ago if this is not so */
   for(p = pParse->pAinc; p; p = p->pNext){
     pDb = &db->aDb[p->iDb];
     memId = p->regCtr;
     assert( sqlite3SchemaMutexHeld(db, 0, pDb->pSchema) );
     sqlite3OpenTable(pParse, 0, p->iDb, pDb->pSchema->pSeqTab, OP_OpenRead);
     sqlite3VdbeAddOp3(v, OP_Null, 0, memId, memId+1);
     addr = sqlite3VdbeCurrentAddr(v);
     sqlite3VdbeAddOp4(v, OP_String8, 0, memId-1, 0, p->pTab->zName, 0);
     sqlite3VdbeAddOp2(v, OP_Rewind, 0, addr+9); VdbeCoverage(v);
     sqlite3VdbeAddOp3(v, OP_Column, 0, 0, memId);
     sqlite3VdbeAddOp3(v, OP_Ne, memId-1, addr+7, memId); VdbeCoverage(v);
     sqlite3VdbeChangeP5(v, SQLITE_JUMPIFNULL);
     sqlite3VdbeAddOp2(v, OP_Rowid, 0, memId+1);
     sqlite3VdbeAddOp3(v, OP_Column, 0, 1, memId);
     sqlite3VdbeAddOp2(v, OP_Goto, 0, addr+9);
     sqlite3VdbeAddOp2(v, OP_Next, 0, addr+2); VdbeCoverage(v);
     sqlite3VdbeAddOp2(v, OP_Integer, 0, memId);
     sqlite3VdbeAddOp0(v, OP_Close);
   }
 }

Here is the call graph for this function:

SQLITE_PRIVATE void sqlite3AutoincrementEnd ( Parse * pParse )

Definition at line 99937 of file sqlite3.c.

References sqlite3::aDb, Parse::db, AutoincInfo::iDb, Parse::pAinc, AutoincInfo::pNext, Db::pSchema, Schema::pSeqTab, Parse::pVdbe, AutoincInfo::regCtr, sqlite3GetTempReg(), sqlite3OpenTable(), sqlite3ReleaseTempReg(), sqlite3VdbeAddOp0(), sqlite3VdbeAddOp1(), sqlite3VdbeAddOp2(), sqlite3VdbeAddOp3(), sqlite3VdbeChangeP5(), and sqlite3VdbeJumpHere().

Referenced by sqlite3DeleteFrom(), sqlite3Insert(), and sqlite3Update().

                                                           {
   AutoincInfo *p;
   Vdbe *v = pParse->pVdbe;
   sqlite3 *db = pParse->db;
 
   assert( v );
   for(p = pParse->pAinc; p; p = p->pNext){
     Db *pDb = &db->aDb[p->iDb];
     int j1;
     int iRec;
     int memId = p->regCtr;
 
     iRec = sqlite3GetTempReg(pParse);
     assert( sqlite3SchemaMutexHeld(db, 0, pDb->pSchema) );
     sqlite3OpenTable(pParse, 0, p->iDb, pDb->pSchema->pSeqTab, OP_OpenWrite);
     j1 = sqlite3VdbeAddOp1(v, OP_NotNull, memId+1); VdbeCoverage(v);
     sqlite3VdbeAddOp2(v, OP_NewRowid, 0, memId+1);
     sqlite3VdbeJumpHere(v, j1);
     sqlite3VdbeAddOp3(v, OP_MakeRecord, memId-1, 2, iRec);
     sqlite3VdbeAddOp3(v, OP_Insert, 0, iRec, memId+1);
     sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
     sqlite3VdbeAddOp0(v, OP_Close);
     sqlite3ReleaseTempReg(pParse, iRec);
   }
 }

Here is the call graph for this function:

SQLITE_PRIVATE void sqlite3AutoLoadExtensions ( sqlite3 * db )

Definition at line 103101 of file sqlite3.c.

References sqlite3_free(), sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3ErrorWithMsg(), and sqlite3MutexAlloc().

                                                           {
   int i;
   int go = 1;
   int rc;
   int (*xInit)(sqlite3*,char**,const sqlite3_api_routines*);
 
   wsdAutoextInit;
   if( wsdAutoext.nExt==0 ){
     /* Common case: early out without every having to acquire a mutex */
     return;
   }
   for(i=0; go; i++){
     char *zErrmsg;
 #if SQLITE_THREADSAFE
     sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER);
 #endif
     sqlite3_mutex_enter(mutex);
     if( i>=wsdAutoext.nExt ){
       xInit = 0;
       go = 0;
     }else{
       xInit = (int(*)(sqlite3*,char**,const sqlite3_api_routines*))
               wsdAutoext.aExt[i];
     }
     sqlite3_mutex_leave(mutex);
     zErrmsg = 0;
     if( xInit && (rc = xInit(db, &zErrmsg, &sqlite3Apis))!=0 ){
       sqlite3ErrorWithMsg(db, rc,
             "automatic extension loading failed: %s", zErrmsg);
       go = 0;
     }
     sqlite3_free(zErrmsg);
   }
 }

Here is the call graph for this function:

SQLITE_PRIVATE void sqlite3BackupRestart ( sqlite3_backup * pBackup )

Definition at line 63051 of file sqlite3.c.

References sqlite3_backup::iNext, and sqlite3_backup::pNext.

Referenced by sqlite3PagerCommitPhaseOne().

                                                                  {
   sqlite3_backup *p;                   /* Iterator variable */
   for(p=pBackup; p; p=p->pNext){
     assert( sqlite3_mutex_held(p->pSrc->pBt->mutex) );
     p->iNext = 1;
   }
 }

SQLITE_PRIVATE void sqlite3BackupUpdate	(	sqlite3_backup *	pBackup,
		Pgno	iPage,
		const u8 *	aData
	)

Definition at line 63018 of file sqlite3.c.

References sqlite3_backup::iNext, sqlite3::mutex, sqlite3_backup::pDestDb, sqlite3_backup::pNext, sqlite3_backup::rc, sqlite3_mutex_enter(), and sqlite3_mutex_leave().

                                                                                              {
   sqlite3_backup *p;                   /* Iterator variable */
   for(p=pBackup; p; p=p->pNext){
     assert( sqlite3_mutex_held(p->pSrc->pBt->mutex) );
     if( !isFatalError(p->rc) && iPage<p->iNext ){
       /* The backup process p has already copied page iPage. But now it
       ** has been modified by a transaction on the source pager. Copy
       ** the new data into the backup.
       */
       int rc;
       assert( p->pDestDb );
       sqlite3_mutex_enter(p->pDestDb->mutex);
       rc = backupOnePage(p, iPage, aData, 1);
       sqlite3_mutex_leave(p->pDestDb->mutex);
       assert( rc!=SQLITE_BUSY && rc!=SQLITE_LOCKED );
       if( rc!=SQLITE_OK ){
         p->rc = rc;
       }
     }
   }
 }

Here is the call graph for this function:

SQLITE_PRIVATE void sqlite3BeginBenignMalloc ( void )

Definition at line 16933 of file sqlite3.c.

Referenced by sqlite3PagerAcquire(), sqlite3PagerClose(), sqlite3RollbackAll(), sqlite3VdbeTransferError(), sqlite3WalClose(), and sqlite3WalDefaultHook().

                                                   {
   wsdHooksInit;
   if( wsdHooks.xBenignBegin ){
     wsdHooks.xBenignBegin();
   }
 }

SQLITE_PRIVATE void sqlite3BeginParse	(	Parse *	pParse,
		int	explainFlag
	)

Definition at line 90841 of file sqlite3.c.

References Parse::explain, and Parse::nVar.

                                                                      {
   pParse->explain = (u8)explainFlag;
   pParse->nVar = 0;
 }

SQLITE_PRIVATE void sqlite3BeginTransaction	(	Parse *	pParse,
		int	type
	)

Definition at line 94601 of file sqlite3.c.

References Parse::db, sqlite3::nDb, sqlite3AuthCheck(), sqlite3GetVdbe(), sqlite3VdbeAddOp2(), and sqlite3VdbeUsesBtree().

                                                                     {
   sqlite3 *db;
   Vdbe *v;
   int i;
 
   assert( pParse!=0 );
   db = pParse->db;
   assert( db!=0 );
 /*  if( db->aDb[0].pBt==0 ) return; */
   if( sqlite3AuthCheck(pParse, SQLITE_TRANSACTION, "BEGIN", 0, 0) ){
     return;
   }
   v = sqlite3GetVdbe(pParse);
   if( !v ) return;
   if( type!=TK_DEFERRED ){
     for(i=0; i<db->nDb; i++){
       sqlite3VdbeAddOp2(v, OP_Transaction, i, (type==TK_EXCLUSIVE)+1);
       sqlite3VdbeUsesBtree(v, i);
     }
   }
   sqlite3VdbeAddOp2(v, OP_AutoCommit, 0, 0);
 }

Here is the call graph for this function:

SQLITE_PRIVATE void sqlite3BeginTrigger	(	Parse *	pParse,
		Token *	pName1,
		Token *	pName2,
		int	tr_tm,
		int	op,
		IdList *	pColumns,
		SrcList *	pTableName,
		Expr *	pWhen,
		int	isTemp,
		int	noErr
	)

Definition at line 112367 of file sqlite3.c.

References sqlite3::aDb, sqlite3::sqlite3InitInfo::busy, Parse::db, sqlite3::sqlite3InitInfo::iDb, sqlite3::mallocFailed, Token::n, Trigger::op, sqlite3::sqlite3InitInfo::orphanTrigger, Trigger::pColumns, Parse::pNewTrigger, Db::pSchema, Table::pSchema, Trigger::pSchema, Table::pSelect, Trigger::pTabSchema, Trigger::pWhen, sqlite3_strnicmp(), sqlite3AuthCheck(), sqlite3CheckObjectName(), sqlite3CodeVerifySchema(), sqlite3DbFree(), sqlite3DbMallocZero(), sqlite3DbStrDup(), sqlite3DeleteTrigger(), sqlite3ErrorMsg(), sqlite3ExprDelete(), sqlite3ExprDup(), sqlite3FixInit(), sqlite3FixSrcList(), sqlite3HashFind(), sqlite3IdListDelete(), sqlite3IdListDup(), sqlite3NameFromToken(), sqlite3SchemaToIndex(), sqlite3SrcListDelete(), sqlite3SrcListLookup(), sqlite3TwoPartName(), Trigger::table, Trigger::tr_tm, Schema::trigHash, SrcList::SrcList_item::zDatabase, Db::zName, Table::zName, SrcList::SrcList_item::zName, and Trigger::zName.

  {
   Trigger *pTrigger = 0;  /* The new trigger */
   Table *pTab;            /* Table that the trigger fires off of */
   char *zName = 0;        /* Name of the trigger */
   sqlite3 *db = pParse->db;  /* The database connection */
   int iDb;                /* The database to store the trigger in */
   Token *pName;           /* The unqualified db name */
   DbFixer sFix;           /* State vector for the DB fixer */
   int iTabDb;             /* Index of the database holding pTab */
 
   assert( pName1!=0 );   /* pName1->z might be NULL, but not pName1 itself */
   assert( pName2!=0 );
   assert( op==TK_INSERT || op==TK_UPDATE || op==TK_DELETE );
   assert( op>0 && op<0xff );
   if( isTemp ){
     /* If TEMP was specified, then the trigger name may not be qualified. */
     if( pName2->n>0 ){
       sqlite3ErrorMsg(pParse, "temporary trigger may not have qualified name");
       goto trigger_cleanup;
     }
     iDb = 1;
     pName = pName1;
   }else{
     /* Figure out the db that the trigger will be created in */
     iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName);
     if( iDb<0 ){
       goto trigger_cleanup;
     }
   }
   if( !pTableName || db->mallocFailed ){
     goto trigger_cleanup;
   }
 
   /* A long-standing parser bug is that this syntax was allowed:
   **
   **    CREATE TRIGGER attached.demo AFTER INSERT ON attached.tab ....
   **                                                 ^^^^^^^^
   **
   ** To maintain backwards compatibility, ignore the database
   ** name on pTableName if we are reparsing out of SQLITE_MASTER.
   */
   if( db->init.busy && iDb!=1 ){
     sqlite3DbFree(db, pTableName->a[0].zDatabase);
     pTableName->a[0].zDatabase = 0;
   }
 
   /* If the trigger name was unqualified, and the table is a temp table,
   ** then set iDb to 1 to create the trigger in the temporary database.
   ** If sqlite3SrcListLookup() returns 0, indicating the table does not
   ** exist, the error is caught by the block below.
   */
   pTab = sqlite3SrcListLookup(pParse, pTableName);
   if( db->init.busy==0 && pName2->n==0 && pTab
         && pTab->pSchema==db->aDb[1].pSchema ){
     iDb = 1;
   }
 
   /* Ensure the table name matches database name and that the table exists */
   if( db->mallocFailed ) goto trigger_cleanup;
   assert( pTableName->nSrc==1 );
   sqlite3FixInit(&sFix, pParse, iDb, "trigger", pName);
   if( sqlite3FixSrcList(&sFix, pTableName) ){
     goto trigger_cleanup;
   }
   pTab = sqlite3SrcListLookup(pParse, pTableName);
   if( !pTab ){
     /* The table does not exist. */
     if( db->init.iDb==1 ){
       /* Ticket #3810.
       ** Normally, whenever a table is dropped, all associated triggers are
       ** dropped too.  But if a TEMP trigger is created on a non-TEMP table
       ** and the table is dropped by a different database connection, the
       ** trigger is not visible to the database connection that does the
       ** drop so the trigger cannot be dropped.  This results in an
       ** "orphaned trigger" - a trigger whose associated table is missing.
       */
       db->init.orphanTrigger = 1;
     }
     goto trigger_cleanup;
   }
   if( IsVirtual(pTab) ){
     sqlite3ErrorMsg(pParse, "cannot create triggers on virtual tables");
     goto trigger_cleanup;
   }
 
   /* Check that the trigger name is not reserved and that no trigger of the
   ** specified name exists */
   zName = sqlite3NameFromToken(db, pName);
   if( !zName || SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){
     goto trigger_cleanup;
   }
   assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
   if( sqlite3HashFind(&(db->aDb[iDb].pSchema->trigHash),zName) ){
     if( !noErr ){
       sqlite3ErrorMsg(pParse, "trigger %T already exists", pName);
     }else{
       assert( !db->init.busy );
       sqlite3CodeVerifySchema(pParse, iDb);
     }
     goto trigger_cleanup;
   }
 
   /* Do not create a trigger on a system table */
   if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0 ){
     sqlite3ErrorMsg(pParse, "cannot create trigger on system table");
     goto trigger_cleanup;
   }
 
   /* INSTEAD of triggers are only for views and views only support INSTEAD
   ** of triggers.
   */
   if( pTab->pSelect && tr_tm!=TK_INSTEAD ){
     sqlite3ErrorMsg(pParse, "cannot create %s trigger on view: %S", 
         (tr_tm == TK_BEFORE)?"BEFORE":"AFTER", pTableName, 0);
     goto trigger_cleanup;
   }
   if( !pTab->pSelect && tr_tm==TK_INSTEAD ){
     sqlite3ErrorMsg(pParse, "cannot create INSTEAD OF"
         " trigger on table: %S", pTableName, 0);
     goto trigger_cleanup;
   }
   iTabDb = sqlite3SchemaToIndex(db, pTab->pSchema);
 
 #ifndef SQLITE_OMIT_AUTHORIZATION
   {
     int code = SQLITE_CREATE_TRIGGER;
     const char *zDb = db->aDb[iTabDb].zName;
     const char *zDbTrig = isTemp ? db->aDb[1].zName : zDb;
     if( iTabDb==1 || isTemp ) code = SQLITE_CREATE_TEMP_TRIGGER;
     if( sqlite3AuthCheck(pParse, code, zName, pTab->zName, zDbTrig) ){
       goto trigger_cleanup;
     }
     if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(iTabDb),0,zDb)){
       goto trigger_cleanup;
     }
   }
 #endif
 
   /* INSTEAD OF triggers can only appear on views and BEFORE triggers
   ** cannot appear on views.  So we might as well translate every
   ** INSTEAD OF trigger into a BEFORE trigger.  It simplifies code
   ** elsewhere.
   */
   if (tr_tm == TK_INSTEAD){
     tr_tm = TK_BEFORE;
   }
 
   /* Build the Trigger object */
   pTrigger = (Trigger*)sqlite3DbMallocZero(db, sizeof(Trigger));
   if( pTrigger==0 ) goto trigger_cleanup;
   pTrigger->zName = zName;
   zName = 0;
   pTrigger->table = sqlite3DbStrDup(db, pTableName->a[0].zName);
   pTrigger->pSchema = db->aDb[iDb].pSchema;
   pTrigger->pTabSchema = pTab->pSchema;
   pTrigger->op = (u8)op;
   pTrigger->tr_tm = tr_tm==TK_BEFORE ? TRIGGER_BEFORE : TRIGGER_AFTER;
   pTrigger->pWhen = sqlite3ExprDup(db, pWhen, EXPRDUP_REDUCE);
   pTrigger->pColumns = sqlite3IdListDup(db, pColumns);
   assert( pParse->pNewTrigger==0 );
   pParse->pNewTrigger = pTrigger;
 
 trigger_cleanup:
   sqlite3DbFree(db, zName);
   sqlite3SrcListDelete(db, pTableName);
   sqlite3IdListDelete(db, pColumns);
   sqlite3ExprDelete(db, pWhen);
   if( !pParse->pNewTrigger ){
     sqlite3DeleteTrigger(db, pTrigger);
   }else{
     assert( pParse->pNewTrigger==pTrigger );
   }
 }

Here is the call graph for this function:

SQLITE_PRIVATE void sqlite3BeginWriteOperation	(	Parse *	pParse,
		int	setStatement,
		int	iDb
	)

Definition at line 94762 of file sqlite3.c.

References Parse::isMultiWrite, sqlite3CodeVerifySchema(), and Parse::writeMask.

Referenced by sqlite3AlterBeginAddColumn(), sqlite3AlterRenameTable(), sqlite3CodeDropTable(), sqlite3CreateIndex(), sqlite3DeleteFrom(), sqlite3DropIndex(), sqlite3DropTable(), sqlite3DropTriggerPtr(), sqlite3FinishTrigger(), sqlite3Insert(), sqlite3Pragma(), sqlite3Reindex(), sqlite3StartTable(), and sqlite3Update().

                                                                                         {
   Parse *pToplevel = sqlite3ParseToplevel(pParse);
   sqlite3CodeVerifySchema(pParse, iDb);
   DbMaskSet(pToplevel->writeMask, iDb);
   pToplevel->isMultiWrite |= setStatement;
 }

Here is the call graph for this function:

SQLITE_PRIVATE void sqlite3BenignMallocHooks	(	void(*)(void)	xBenignBegin,
		void(*)(void)	xBenignEnd
	)

Definition at line 16919 of file sqlite3.c.

Referenced by sqlite3_test_control().

  {
   wsdHooksInit;
   wsdHooks.xBenignBegin = xBenignBegin;
   wsdHooks.xBenignEnd = xBenignEnd;
 }

SQLITE_PRIVATE CollSeq * sqlite3BinaryCompareCollSeq	(	Parse *	pParse,
		Expr *	pLeft,
		Expr *	pRight
	)

Definition at line 83080 of file sqlite3.c.

References Expr::flags, and sqlite3ExprCollSeq().

Referenced by sqlite3CodeSubselect(), and sqlite3FindInIndex().

  {
   CollSeq *pColl;
   assert( pLeft );
   if( pLeft->flags & EP_Collate ){
     pColl = sqlite3ExprCollSeq(pParse, pLeft);
   }else if( pRight && (pRight->flags & EP_Collate)!=0 ){
     pColl = sqlite3ExprCollSeq(pParse, pRight);
   }else{
     pColl = sqlite3ExprCollSeq(pParse, pLeft);
     if( !pColl ){
       pColl = sqlite3ExprCollSeq(pParse, pRight);
     }
   }
   return pColl;
 }

Here is the call graph for this function:

SQLITE_PRIVATE int sqlite3BitvecBuiltinTest	(	int	sz,
		int *	aOp
	)

Definition at line 39210 of file sqlite3.c.

References sqlite3_free(), sqlite3_malloc(), sqlite3_randomness(), sqlite3BitvecClear(), sqlite3BitvecCreate(), sqlite3BitvecDestroy(), sqlite3BitvecSet(), sqlite3BitvecSize(), and sqlite3BitvecTest().

Referenced by sqlite3_test_control().

                                                              {
   Bitvec *pBitvec = 0;
   unsigned char *pV = 0;
   int rc = -1;
   int i, nx, pc, op;
   void *pTmpSpace;
 
   /* Allocate the Bitvec to be tested and a linear array of
   ** bits to act as the reference */
   pBitvec = sqlite3BitvecCreate( sz );
   pV = sqlite3MallocZero( (sz+7)/8 + 1 );
   pTmpSpace = sqlite3_malloc(BITVEC_SZ);
   if( pBitvec==0 || pV==0 || pTmpSpace==0  ) goto bitvec_end;
 
   /* NULL pBitvec tests */
   sqlite3BitvecSet(0, 1);
   sqlite3BitvecClear(0, 1, pTmpSpace);
 
   /* Run the program */
   pc = 0;
   while( (op = aOp[pc])!=0 ){
     switch( op ){
       case 1:
       case 2:
       case 5: {
         nx = 4;
         i = aOp[pc+2] - 1;
         aOp[pc+2] += aOp[pc+3];
         break;
       }
       case 3:
       case 4: 
       default: {
         nx = 2;
         sqlite3_randomness(sizeof(i), &i);
         break;
       }
     }
     if( (--aOp[pc+1]) > 0 ) nx = 0;
     pc += nx;
     i = (i & 0x7fffffff)%sz;
     if( (op & 1)!=0 ){
       SETBIT(pV, (i+1));
       if( op!=5 ){
         if( sqlite3BitvecSet(pBitvec, i+1) ) goto bitvec_end;
       }
     }else{
       CLEARBIT(pV, (i+1));
       sqlite3BitvecClear(pBitvec, i+1, pTmpSpace);
     }
   }
 
   /* Test to make sure the linear array exactly matches the
   ** Bitvec object.  Start with the assumption that they do
   ** match (rc==0).  Change rc to non-zero if a discrepancy
   ** is found.
   */
   rc = sqlite3BitvecTest(0,0) + sqlite3BitvecTest(pBitvec, sz+1)
           + sqlite3BitvecTest(pBitvec, 0)
           + (sqlite3BitvecSize(pBitvec) - sz);
   for(i=1; i<=sz; i++){
     if(  (TESTBIT(pV,i))!=sqlite3BitvecTest(pBitvec,i) ){
       rc = i;
       break;
     }
   }
 
   /* Free allocated structure */
 bitvec_end:
   sqlite3_free(pTmpSpace);
   sqlite3_free(pV);
   sqlite3BitvecDestroy(pBitvec);
   return rc;
 }

Here is the call graph for this function:

SQLITE_PRIVATE void sqlite3BitvecClear	(	Bitvec *	p,
		u32	i,
		void *	pBuf
	)

Definition at line 39113 of file sqlite3.c.

References Bitvec::iDivisor, Bitvec::iSize, and Bitvec::nSet.

Referenced by sqlite3BitvecBuiltinTest(), and sqlite3PagerMovepage().

                                                                     {
   if( p==0 ) return;
   assert( i>0 );
   i--;
   while( p->iDivisor ){
     u32 bin = i/p->iDivisor;
     i = i%p->iDivisor;
     p = p->u.apSub[bin];
     if (!p) {
       return;
     }
   }
   if( p->iSize<=BITVEC_NBIT ){
     p->u.aBitmap[i/BITVEC_SZELEM] &= ~(1 << (i&(BITVEC_SZELEM-1)));
   }else{
     unsigned int j;
     u32 *aiValues = pBuf;
     memcpy(aiValues, p->u.aHash, sizeof(p->u.aHash));
     memset(p->u.aHash, 0, sizeof(p->u.aHash));
     p->nSet = 0;
     for(j=0; j<BITVEC_NINT; j++){
       if( aiValues[j] && aiValues[j]!=(i+1) ){
         u32 h = BITVEC_HASH(aiValues[j]-1);
         p->nSet++;
         while( p->u.aHash[h] ){
           h++;
           if( h>=BITVEC_NINT ) h = 0;
         }
         p->u.aHash[h] = aiValues[j];
       }
     }
   }
 }

SQLITE_PRIVATE Bitvec * sqlite3BitvecCreate ( u32 iSize )

Definition at line 38991 of file sqlite3.c.

References Bitvec::iSize.

Referenced by sqlite3BitvecBuiltinTest(), sqlite3BitvecSet(), and sqlite3PagerOpenSavepoint().

                                                      {
   Bitvec *p;
   assert( sizeof(*p)==BITVEC_SZ );
   p = sqlite3MallocZero( sizeof(*p) );
   if( p ){
     p->iSize = iSize;
   }
   return p;
 }

SQLITE_PRIVATE void sqlite3BitvecDestroy ( Bitvec * p )

Definition at line 39150 of file sqlite3.c.

References Bitvec::iDivisor, sqlite3_free(), and sqlite3BitvecDestroy().

Referenced by sqlite3BitvecBuiltinTest(), sqlite3BitvecDestroy(), and sqlite3PagerSavepoint().

                                                    {
   if( p==0 ) return;
   if( p->iDivisor ){
     unsigned int i;
     for(i=0; i<BITVEC_NPTR; i++){
       sqlite3BitvecDestroy(p->u.apSub[i]);
     }
   }
   sqlite3_free(p);
 }

Here is the call graph for this function:

SQLITE_PRIVATE int sqlite3BitvecSet	(	Bitvec *	p,
		u32	i
	)

Definition at line 39042 of file sqlite3.c.

References Bitvec::iDivisor, Bitvec::iSize, Bitvec::nSet, and sqlite3BitvecCreate().

Referenced by sqlite3BitvecBuiltinTest(), and sqlite3PagerAcquire().

                                                      {
   u32 h;
   if( p==0 ) return SQLITE_OK;
   assert( i>0 );
   assert( i<=p->iSize );
   i--;
   while((p->iSize > BITVEC_NBIT) && p->iDivisor) {
     u32 bin = i/p->iDivisor;
     i = i%p->iDivisor;
     if( p->u.apSub[bin]==0 ){
       p->u.apSub[bin] = sqlite3BitvecCreate( p->iDivisor );
       if( p->u.apSub[bin]==0 ) return SQLITE_NOMEM;
     }
     p = p->u.apSub[bin];
   }
   if( p->iSize<=BITVEC_NBIT ){
     p->u.aBitmap[i/BITVEC_SZELEM] |= 1 << (i&(BITVEC_SZELEM-1));
     return SQLITE_OK;
   }
   h = BITVEC_HASH(i++);
   /* if there wasn't a hash collision, and this doesn't */
   /* completely fill the hash, then just add it without */
   /* worring about sub-dividing and re-hashing. */
   if( !p->u.aHash[h] ){
     if (p->nSet<(BITVEC_NINT-1)) {
       goto bitvec_set_end;
     } else {
       goto bitvec_set_rehash;
     }
   }
   /* there was a collision, check to see if it's already */
   /* in hash, if not, try to find a spot for it */
   do {
     if( p->u.aHash[h]==i ) return SQLITE_OK;
     h++;
     if( h>=BITVEC_NINT ) h = 0;
   } while( p->u.aHash[h] );
   /* we didn't find it in the hash.  h points to the first */
   /* available free spot. check to see if this is going to */
   /* make our hash too "full".  */
 bitvec_set_rehash:
   if( p->nSet>=BITVEC_MXHASH ){
     unsigned int j;
     int rc;
     u32 *aiValues = sqlite3StackAllocRaw(0, sizeof(p->u.aHash));
     if( aiValues==0 ){
       return SQLITE_NOMEM;
     }else{
       memcpy(aiValues, p->u.aHash, sizeof(p->u.aHash));
       memset(p->u.apSub, 0, sizeof(p->u.apSub));
       p->iDivisor = (p->iSize + BITVEC_NPTR - 1)/BITVEC_NPTR;
       rc = sqlite3BitvecSet(p, i);
       for(j=0; j<BITVEC_NINT; j++){
         if( aiValues[j] ) rc |= sqlite3BitvecSet(p, aiValues[j]);
       }
       sqlite3StackFree(0, aiValues);
       return rc;
     }
   }
 bitvec_set_end:
   p->nSet++;
   p->u.aHash[h] = i;
   return SQLITE_OK;
 }

Here is the call graph for this function:

SQLITE_PRIVATE u32 sqlite3BitvecSize ( Bitvec * p )

Definition at line 39165 of file sqlite3.c.

References Bitvec::iSize.

Referenced by sqlite3BitvecBuiltinTest().

                                                {
   return p->iSize;
 }

SQLITE_PRIVATE int sqlite3BitvecTest	(	Bitvec *	p,
		u32	i
	)

Definition at line 39006 of file sqlite3.c.

References Bitvec::iDivisor, and Bitvec::iSize.

Referenced by sqlite3BitvecBuiltinTest().

                                                       {
   if( p==0 ) return 0;
   if( i>p->iSize || i==0 ) return 0;
   i--;
   while( p->iDivisor ){
     u32 bin = i/p->iDivisor;
     i = i%p->iDivisor;
     p = p->u.apSub[bin];
     if (!p) {
       return 0;
     }
   }
   if( p->iSize<=BITVEC_NBIT ){
     return (p->u.aBitmap[i/BITVEC_SZELEM] & (1<<(i&(BITVEC_SZELEM-1))))!=0;
   } else{
     u32 h = BITVEC_HASH(i++);
     while( p->u.aHash[h] ){
       if( p->u.aHash[h]==i ) return 1;
       h = (h+1) % BITVEC_NINT;
     }
     return 0;
   }
 }

SQLITE_PRIVATE int sqlite3BtreeBeginStmt	(	Btree *	p,
		int	iStatement
	)

Definition at line 56822 of file sqlite3.c.

References Btree::pBt, BtShared::pPager, sqlite3BtreeEnter(), sqlite3BtreeLeave(), and sqlite3PagerOpenSavepoint().

Referenced by sqlite3VdbeExec().

                                                                   {
   int rc;
   BtShared *pBt = p->pBt;
   sqlite3BtreeEnter(p);
   assert( p->inTrans==TRANS_WRITE );
   assert( (pBt->btsFlags & BTS_READ_ONLY)==0 );
   assert( iStatement>0 );
   assert( iStatement>p->db->nSavepoint );
   assert( pBt->inTransaction==TRANS_WRITE );
   /* At the pager level, a statement transaction is a savepoint with
   ** an index greater than all savepoints created explicitly using
   ** SQL statements. It is illegal to open, release or rollback any
   ** such savepoints while the statement transaction savepoint is active.
   */
   rc = sqlite3PagerOpenSavepoint(pBt->pPager, iStatement);
   sqlite3BtreeLeave(p);
   return rc;
 }

Here is the call graph for this function:

SQLITE_PRIVATE int sqlite3BtreeBeginTrans	(	Btree *	p,
		int	wrflag
	)

Definition at line 55961 of file sqlite3.c.

References MemPage::aData, BtShared::btsFlags, Btree::db, BtLock::eLock, Btree::inTrans, BtShared::inTransaction, Btree::lock, BtShared::nPage, sqlite3::nSavepoint, BtShared::nTransaction, Btree::pBt, BtLock::pBtree, MemPage::pDbPage, BtShared::pLock, BtLock::pNext, BtShared::pPage1, BtShared::pPager, BtShared::pWriter, Btree::sharable, sqlite3BtreeEnter(), sqlite3BtreeLeave(), sqlite3Get4byte(), sqlite3PagerBegin(), sqlite3PagerOpenSavepoint(), sqlite3PagerWrite(), sqlite3Put4byte(), and sqlite3TempInMemory().

Referenced by sqlite3_backup_step(), sqlite3BtreeSetVersion(), sqlite3RunVacuum(), and sqlite3VdbeExec().

                                                                {
   sqlite3 *pBlock = 0;
   BtShared *pBt = p->pBt;
   int rc = SQLITE_OK;
 
   sqlite3BtreeEnter(p);
   btreeIntegrity(p);
 
   /* If the btree is already in a write-transaction, or it
   ** is already in a read-transaction and a read-transaction
   ** is requested, this is a no-op.
   */
   if( p->inTrans==TRANS_WRITE || (p->inTrans==TRANS_READ && !wrflag) ){
     goto trans_begun;
   }
   assert( pBt->inTransaction==TRANS_WRITE || IfNotOmitAV(pBt->bDoTruncate)==0 );
 
   /* Write transactions are not possible on a read-only database */
   if( (pBt->btsFlags & BTS_READ_ONLY)!=0 && wrflag ){
     rc = SQLITE_READONLY;
     goto trans_begun;
   }
 
 #ifndef SQLITE_OMIT_SHARED_CACHE
   /* If another database handle has already opened a write transaction 
   ** on this shared-btree structure and a second write transaction is
   ** requested, return SQLITE_LOCKED.
   */
   if( (wrflag && pBt->inTransaction==TRANS_WRITE)
    || (pBt->btsFlags & BTS_PENDING)!=0
   ){
     pBlock = pBt->pWriter->db;
   }else if( wrflag>1 ){
     BtLock *pIter;
     for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
       if( pIter->pBtree!=p ){
         pBlock = pIter->pBtree->db;
         break;
       }
     }
   }
   if( pBlock ){
     sqlite3ConnectionBlocked(p->db, pBlock);
     rc = SQLITE_LOCKED_SHAREDCACHE;
     goto trans_begun;
   }
 #endif
 
   /* Any read-only or read-write transaction implies a read-lock on 
   ** page 1. So if some other shared-cache client already has a write-lock 
   ** on page 1, the transaction cannot be opened. */
   rc = querySharedCacheTableLock(p, MASTER_ROOT, READ_LOCK);
   if( SQLITE_OK!=rc ) goto trans_begun;
 
   pBt->btsFlags &= ~BTS_INITIALLY_EMPTY;
   if( pBt->nPage==0 ) pBt->btsFlags |= BTS_INITIALLY_EMPTY;
   do {
     /* Call lockBtree() until either pBt->pPage1 is populated or
     ** lockBtree() returns something other than SQLITE_OK. lockBtree()
     ** may return SQLITE_OK but leave pBt->pPage1 set to 0 if after
     ** reading page 1 it discovers that the page-size of the database 
     ** file is not pBt->pageSize. In this case lockBtree() will update
     ** pBt->pageSize to the page-size of the file on disk.
     */
     while( pBt->pPage1==0 && SQLITE_OK==(rc = lockBtree(pBt)) );
 
     if( rc==SQLITE_OK && wrflag ){
       if( (pBt->btsFlags & BTS_READ_ONLY)!=0 ){
         rc = SQLITE_READONLY;
       }else{
         rc = sqlite3PagerBegin(pBt->pPager,wrflag>1,sqlite3TempInMemory(p->db));
         if( rc==SQLITE_OK ){
           rc = newDatabase(pBt);
         }
       }
     }
   
     if( rc!=SQLITE_OK ){
       unlockBtreeIfUnused(pBt);
     }
   }while( (rc&0xFF)==SQLITE_BUSY && pBt->inTransaction==TRANS_NONE &&
           btreeInvokeBusyHandler(pBt) );
 
   if( rc==SQLITE_OK ){
     if( p->inTrans==TRANS_NONE ){
       pBt->nTransaction++;
 #ifndef SQLITE_OMIT_SHARED_CACHE
       if( p->sharable ){
         assert( p->lock.pBtree==p && p->lock.iTable==1 );
         p->lock.eLock = READ_LOCK;
         p->lock.pNext = pBt->pLock;
         pBt->pLock = &p->lock;
       }
 #endif
     }
     p->inTrans = (wrflag?TRANS_WRITE:TRANS_READ);
     if( p->inTrans>pBt->inTransaction ){
       pBt->inTransaction = p->inTrans;
     }
     if( wrflag ){
       MemPage *pPage1 = pBt->pPage1;
 #ifndef SQLITE_OMIT_SHARED_CACHE
       assert( !pBt->pWriter );
       pBt->pWriter = p;
       pBt->btsFlags &= ~BTS_EXCLUSIVE;
       if( wrflag>1 ) pBt->btsFlags |= BTS_EXCLUSIVE;
 #endif
 
       /* If the db-size header field is incorrect (as it may be if an old
       ** client has been writing the database file), update it now. Doing
       ** this sooner rather than later means the database size can safely 
       ** re-read the database size from page 1 if a savepoint or transaction
       ** rollback occurs within the transaction.
       */
       if( pBt->nPage!=get4byte(&pPage1->aData[28]) ){
         rc = sqlite3PagerWrite(pPage1->pDbPage);
         if( rc==SQLITE_OK ){
           put4byte(&pPage1->aData[28], pBt->nPage);
         }
       }
     }
   }
 
 
 trans_begun:
   if( rc==SQLITE_OK && wrflag ){
     /* This call makes sure that the pager has the correct number of
     ** open savepoints. If the second parameter is greater than 0 and
     ** the sub-journal is not already open, then it will be opened here.
     */
     rc = sqlite3PagerOpenSavepoint(pBt->pPager, p->db->nSavepoint);
   }
 
   btreeIntegrity(p);
   sqlite3BtreeLeave(p);
   return rc;
 }

Here is the call graph for this function:

SQLITE_PRIVATE int sqlite3BtreeCheckpoint	(	Btree *	p,
		int	eMode,
		int *	pnLog,
		int *	pnCkpt
	)

Definition at line 62098 of file sqlite3.c.

References BtShared::inTransaction, Btree::pBt, BtShared::pPager, sqlite3BtreeEnter(), sqlite3BtreeLeave(), and sqlite3PagerCheckpoint().

Referenced by sqlite3Checkpoint().

                                                                                        {
   int rc = SQLITE_OK;
   if( p ){
     BtShared *pBt = p->pBt;
     sqlite3BtreeEnter(p);
     if( pBt->inTransaction!=TRANS_NONE ){
       rc = SQLITE_LOCKED;
     }else{
       rc = sqlite3PagerCheckpoint(pBt->pPager, eMode, pnLog, pnCkpt);
     }
     sqlite3BtreeLeave(p);
   }
   return rc;
 }

Here is the call graph for this function:

SQLITE_PRIVATE void sqlite3BtreeClearCursor ( BtCursor * pCur )

Definition at line 53782 of file sqlite3.c.

References BtCursor::eState, BtCursor::pKey, and sqlite3_free().

Referenced by sqlite3BtreeCloseCursor(), sqlite3BtreeTripAllCursors(), and sqlite3VdbeExec().

                                                            {
   assert( cursorHoldsMutex(pCur) );
   sqlite3_free(pCur->pKey);
   pCur->pKey = 0;
   pCur->eState = CURSOR_INVALID;
 }

Here is the call graph for this function:

SQLITE_PRIVATE int sqlite3BtreeClearTable	(	Btree *	p,
		int	iTable,
		int *	pnChange
	)

Definition at line 61123 of file sqlite3.c.

References Btree::pBt, sqlite3BtreeEnter(), and sqlite3BtreeLeave().

Referenced by sqlite3BtreeClearTableOfCursor(), and sqlite3VdbeExec().

                                                                               {
   int rc;
   BtShared *pBt = p->pBt;
   sqlite3BtreeEnter(p);
   assert( p->inTrans==TRANS_WRITE );
 
   rc = saveAllCursors(pBt, (Pgno)iTable, 0);
 
   if( SQLITE_OK==rc ){
     /* Invalidate all incrblob cursors open on table iTable (assuming iTable
     ** is the root of a table b-tree - if it is not, the following call is
     ** a no-op).  */
     invalidateIncrblobCursors(p, 0, 1);
     rc = clearDatabasePage(pBt, (Pgno)iTable, 0, pnChange);
   }
   sqlite3BtreeLeave(p);
   return rc;
 }

Here is the call graph for this function:

SQLITE_PRIVATE int sqlite3BtreeClearTableOfCursor ( BtCursor * pCur )

Definition at line 61147 of file sqlite3.c.

References BtCursor::pBtree, BtCursor::pgnoRoot, and sqlite3BtreeClearTable().

Referenced by sqlite3VdbeExec().

                                                                  {
   return sqlite3BtreeClearTable(pCur->pBtree, pCur->pgnoRoot, 0);
 }

Here is the call graph for this function:

SQLITE_PRIVATE int sqlite3BtreeClose ( Btree * p )

Definition at line 55344 of file sqlite3.c.

References Btree::pBt, BtCursor::pBtree, BtShared::pCursor, Btree::pNext, BtCursor::pNext, BtShared::pPager, Btree::pPrev, BtShared::pSchema, Btree::sharable, sqlite3_free(), sqlite3BtreeCloseCursor(), sqlite3BtreeEnter(), sqlite3BtreeLeave(), sqlite3BtreeRollback(), sqlite3DbFree(), sqlite3PagerClose(), and BtShared::xFreeSchema.

Referenced by sqlite3LeaveMutexAndCloseZombie(), sqlite3RunVacuum(), and sqlite3VdbeFreeCursor().

                                               {
   BtShared *pBt = p->pBt;
   BtCursor *pCur;
 
   /* Close all cursors opened via this handle.  */
   assert( sqlite3_mutex_held(p->db->mutex) );
   sqlite3BtreeEnter(p);
   pCur = pBt->pCursor;
   while( pCur ){
     BtCursor *pTmp = pCur;
     pCur = pCur->pNext;
     if( pTmp->pBtree==p ){
       sqlite3BtreeCloseCursor(pTmp);
     }
   }
 
   /* Rollback any active transaction and free the handle structure.
   ** The call to sqlite3BtreeRollback() drops any table-locks held by
   ** this handle.
   */
   sqlite3BtreeRollback(p, SQLITE_OK, 0);
   sqlite3BtreeLeave(p);
 
   /* If there are still other outstanding references to the shared-btree
   ** structure, return now. The remainder of this procedure cleans 
   ** up the shared-btree.
   */
   assert( p->wantToLock==0 && p->locked==0 );
   if( !p->sharable || removeFromSharingList(pBt) ){
     /* The pBt is no longer on the sharing list, so we can access
     ** it without having to hold the mutex.
     **
     ** Clean out and delete the BtShared object.
     */
     assert( !pBt->pCursor );
     sqlite3PagerClose(pBt->pPager);
     if( pBt->xFreeSchema && pBt->pSchema ){
       pBt->xFreeSchema(pBt->pSchema);
     }
     sqlite3DbFree(0, pBt->pSchema);
     freeTempSpace(pBt);
     sqlite3_free(pBt);
   }
 
 #ifndef SQLITE_OMIT_SHARED_CACHE
   assert( p->wantToLock==0 );
   assert( p->locked==0 );
   if( p->pPrev ) p->pPrev->pNext = p->pNext;
   if( p->pNext ) p->pNext->pPrev = p->pPrev;
 #endif
 
   sqlite3_free(p);
   return SQLITE_OK;
 }

Here is the call graph for this function:

SQLITE_PRIVATE int sqlite3BtreeCloseCursor ( BtCursor * pCur )

Definition at line 57005 of file sqlite3.c.

References BtCursor::aOverflow, BtCursor::apPage, BtCursor::iPage, BtCursor::pBt, BtCursor::pBtree, BtShared::pCursor, BtCursor::pNext, BtCursor::pPrev, sqlite3_free(), sqlite3BtreeClearCursor(), sqlite3BtreeEnter(), and sqlite3BtreeLeave().

Referenced by sqlite3BtreeClose(), and sqlite3VdbeFreeCursor().

                                                           {
   Btree *pBtree = pCur->pBtree;
   if( pBtree ){
     int i;
     BtShared *pBt = pCur->pBt;
     sqlite3BtreeEnter(pBtree);
     sqlite3BtreeClearCursor(pCur);
     if( pCur->pPrev ){
       pCur->pPrev->pNext = pCur->pNext;
     }else{
       pBt->pCursor = pCur->pNext;
     }
     if( pCur->pNext ){
       pCur->pNext->pPrev = pCur->pPrev;
     }
     for(i=0; i<=pCur->iPage; i++){
       releasePage(pCur->apPage[i]);
     }
     unlockBtreeIfUnused(pBt);
     sqlite3_free(pCur->aOverflow);
     /* sqlite3_free(pCur); */
     sqlite3BtreeLeave(pBtree);
   }
   return SQLITE_OK;
 }

Here is the call graph for this function:

SQLITE_PRIVATE int sqlite3BtreeCommit ( Btree * p )

Definition at line 56673 of file sqlite3.c.

References sqlite3BtreeCommitPhaseOne(), sqlite3BtreeCommitPhaseTwo(), sqlite3BtreeEnter(), and sqlite3BtreeLeave().

Referenced by sqlite3RunVacuum().

                                                {
   int rc;
   sqlite3BtreeEnter(p);
   rc = sqlite3BtreeCommitPhaseOne(p, 0);
   if( rc==SQLITE_OK ){
     rc = sqlite3BtreeCommitPhaseTwo(p, 0);
   }
   sqlite3BtreeLeave(p);
   return rc;
 }

Here is the call graph for this function:

SQLITE_PRIVATE int sqlite3BtreeCommitPhaseOne	(	Btree *	p,
		const char *	zMaster
	)

Definition at line 56552 of file sqlite3.c.

References BtShared::autoVacuum, BtShared::bDoTruncate, Btree::inTrans, BtShared::nPage, Btree::pBt, BtShared::pPager, sqlite3BtreeEnter(), sqlite3BtreeLeave(), sqlite3PagerCommitPhaseOne(), and sqlite3PagerTruncateImage().

Referenced by sqlite3_backup_step(), and sqlite3BtreeCommit().

                                                                             {
   int rc = SQLITE_OK;
   if( p->inTrans==TRANS_WRITE ){
     BtShared *pBt = p->pBt;
     sqlite3BtreeEnter(p);
 #ifndef SQLITE_OMIT_AUTOVACUUM
     if( pBt->autoVacuum ){
       rc = autoVacuumCommit(pBt);
       if( rc!=SQLITE_OK ){
         sqlite3BtreeLeave(p);
         return rc;
       }
     }
     if( pBt->bDoTruncate ){
       sqlite3PagerTruncateImage(pBt->pPager, pBt->nPage);
     }
 #endif
     rc = sqlite3PagerCommitPhaseOne(pBt->pPager, zMaster, 0);
     sqlite3BtreeLeave(p);
   }
   return rc;
 }

Here is the call graph for this function:

SQLITE_PRIVATE int sqlite3BtreeCommitPhaseTwo	(	Btree *	p,
		int	bCleanup
	)

Definition at line 56641 of file sqlite3.c.

References Btree::iDataVersion, Btree::inTrans, BtShared::inTransaction, Btree::pBt, BtShared::pPager, sqlite3BtreeEnter(), sqlite3BtreeLeave(), and sqlite3PagerCommitPhaseTwo().

Referenced by sqlite3_backup_step(), and sqlite3BtreeCommit().

                                                                      {
 
   if( p->inTrans==TRANS_NONE ) return SQLITE_OK;
   sqlite3BtreeEnter(p);
   btreeIntegrity(p);
 
   /* If the handle has a write-transaction open, commit the shared-btrees 
   ** transaction and set the shared state to TRANS_READ.
   */
   if( p->inTrans==TRANS_WRITE ){
     int rc;
     BtShared *pBt = p->pBt;
     assert( pBt->inTransaction==TRANS_WRITE );
     assert( pBt->nTransaction>0 );
     rc = sqlite3PagerCommitPhaseTwo(pBt->pPager);
     if( rc!=SQLITE_OK && bCleanup==0 ){
       sqlite3BtreeLeave(p);
       return rc;
     }
     p->iDataVersion--;  /* Compensate for pPager->iDataVersion++; */
     pBt->inTransaction = TRANS_READ;
     btreeClearHasContent(pBt);
   }
 
   btreeEndTransaction(p);
   sqlite3BtreeLeave(p);
   return SQLITE_OK;
 }

Here is the call graph for this function:

SQLITE_PRIVATE int sqlite3BtreeCopyFile	(	Btree *	pTo,
		Btree *	pFrom
	)

Definition at line 63068 of file sqlite3.c.

References BtShared::btsFlags, Btree::db, sqlite3_backup::iNext, Btree::pBt, sqlite3_backup::pDest, sqlite3_file::pMethods, sqlite3_backup::pSrc, sqlite3_backup::pSrcDb, sqlite3_backup_finish(), sqlite3_backup_step(), sqlite3BtreeEnter(), sqlite3BtreeGetPageSize(), sqlite3BtreeLastPage(), sqlite3BtreeLeave(), sqlite3BtreePager(), sqlite3OsFileControl(), sqlite3PagerClearCache(), and sqlite3PagerFile().

Referenced by sqlite3RunVacuum().

                                                                  {
   int rc;
   sqlite3_file *pFd;              /* File descriptor for database pTo */
   sqlite3_backup b;
   sqlite3BtreeEnter(pTo);
   sqlite3BtreeEnter(pFrom);
 
   assert( sqlite3BtreeIsInTrans(pTo) );
   pFd = sqlite3PagerFile(sqlite3BtreePager(pTo));
   if( pFd->pMethods ){
     i64 nByte = sqlite3BtreeGetPageSize(pFrom)*(i64)sqlite3BtreeLastPage(pFrom);
     rc = sqlite3OsFileControl(pFd, SQLITE_FCNTL_OVERWRITE, &nByte);
     if( rc==SQLITE_NOTFOUND ) rc = SQLITE_OK;
     if( rc ) goto copy_finished;
   }
 
   /* Set up an sqlite3_backup object. sqlite3_backup.pDestDb must be set
   ** to 0. This is used by the implementations of sqlite3_backup_step()
   ** and sqlite3_backup_finish() to detect that they are being called
   ** from this function, not directly by the user.
   */
   memset(&b, 0, sizeof(b));
   b.pSrcDb = pFrom->db;
   b.pSrc = pFrom;
   b.pDest = pTo;
   b.iNext = 1;
 
   /* 0x7FFFFFFF is the hard limit for the number of pages in a database
   ** file. By passing this as the number of pages to copy to
   ** sqlite3_backup_step(), we can guarantee that the copy finishes 
   ** within a single call (unless an error occurs). The assert() statement
   ** checks this assumption - (p->rc) should be set to either SQLITE_DONE 
   ** or an error code.
   */
   sqlite3_backup_step(&b, 0x7FFFFFFF);
   assert( b.rc!=SQLITE_OK );
   rc = sqlite3_backup_finish(&b);
   if( rc==SQLITE_OK ){
     pTo->pBt->btsFlags &= ~BTS_PAGESIZE_FIXED;
   }else{
     sqlite3PagerClearCache(sqlite3BtreePager(b.pDest));
   }
 
   assert( sqlite3BtreeIsInTrans(pTo)==0 );
 copy_finished:
   sqlite3BtreeLeave(pFrom);
   sqlite3BtreeLeave(pTo);
   return rc;
 }

Here is the call graph for this function:

SQLITE_PRIVATE int sqlite3BtreeCount	(	BtCursor *	pCur,
		i64 *	pnEntry
	)

Definition at line 61366 of file sqlite3.c.

References MemPage::aData, BtCursor::aiIdx, BtCursor::apPage, MemPage::hdrOffset, MemPage::intKey, BtCursor::iPage, MemPage::leaf, MemPage::nCell, BtCursor::pgnoRoot, and sqlite3Get4byte().

Referenced by sqlite3VdbeExec().

                                                                   {
   i64 nEntry = 0;                      /* Value to return in *pnEntry */
   int rc;                              /* Return code */
 
   if( pCur->pgnoRoot==0 ){
     *pnEntry = 0;
     return SQLITE_OK;
   }
   rc = moveToRoot(pCur);
 
   /* Unless an error occurs, the following loop runs one iteration for each
   ** page in the B-Tree structure (not including overflow pages). 
   */
   while( rc==SQLITE_OK ){
     int iIdx;                          /* Index of child node in parent */
     MemPage *pPage;                    /* Current page of the b-tree */
 
     /* If this is a leaf page or the tree is not an int-key tree, then 
     ** this page contains countable entries. Increment the entry counter
     ** accordingly.
     */
     pPage = pCur->apPage[pCur->iPage];
     if( pPage->leaf || !pPage->intKey ){
       nEntry += pPage->nCell;
     }
 
     /* pPage is a leaf node. This loop navigates the cursor so that it 
     ** points to the first interior cell that it points to the parent of
     ** the next page in the tree that has not yet been visited. The
     ** pCur->aiIdx[pCur->iPage] value is set to the index of the parent cell
     ** of the page, or to the number of cells in the page if the next page
     ** to visit is the right-child of its parent.
     **
     ** If all pages in the tree have been visited, return SQLITE_OK to the
     ** caller.
     */
     if( pPage->leaf ){
       do {
         if( pCur->iPage==0 ){
           /* All pages of the b-tree have been visited. Return successfully. */
           *pnEntry = nEntry;
           return moveToRoot(pCur);
         }
         moveToParent(pCur);
       }while ( pCur->aiIdx[pCur->iPage]>=pCur->apPage[pCur->iPage]->nCell );
 
       pCur->aiIdx[pCur->iPage]++;
       pPage = pCur->apPage[pCur->iPage];
     }
 
     /* Descend to the child node of the cell that the cursor currently 
     ** points at. This is the right-child if (iIdx==pPage->nCell).
     */
     iIdx = pCur->aiIdx[pCur->iPage];
     if( iIdx==pPage->nCell ){
       rc = moveToChild(pCur, get4byte(&pPage->aData[pPage->hdrOffset+8]));
     }else{
       rc = moveToChild(pCur, get4byte(findCell(pPage, iIdx)));
     }
   }
 
   /* An error has occurred. Return an error code. */
   return rc;
 }

Here is the call graph for this function:

SQLITE_PRIVATE int sqlite3BtreeCreateTable	(	Btree *	p,
		int *	piTable,
		int	flags
	)

Definition at line 61045 of file sqlite3.c.

References sqlite3BtreeEnter(), and sqlite3BtreeLeave().

Referenced by sqlite3VdbeExec().

                                                                              {
   int rc;
   sqlite3BtreeEnter(p);
   rc = btreeCreateTable(p, piTable, flags);
   sqlite3BtreeLeave(p);
   return rc;
 }

Here is the call graph for this function:

SQLITE_PRIVATE int sqlite3BtreeCursor	(	Btree *	p,
		int	iTable,
		int	wrFlag,
		struct KeyInfo *	pKeyInfo,
		BtCursor *	pCursor
	)

Definition at line 56963 of file sqlite3.c.

References sqlite3BtreeEnter(), and sqlite3BtreeLeave().

Referenced by sqlite3VdbeExec().

  {
   int rc;
   sqlite3BtreeEnter(p);
   rc = btreeCursor(p, iTable, wrFlag, pKeyInfo, pCur);
   sqlite3BtreeLeave(p);
   return rc;
 }

Here is the call graph for this function:

SQLITE_PRIVATE int sqlite3BtreeCursorHasMoved ( BtCursor * pCur )

Definition at line 53873 of file sqlite3.c.

References BtCursor::eState.

Referenced by sqlite3VdbeCursorMoveto(), and sqlite3VdbeCursorRestore().

                                                              {
   return pCur->eState!=CURSOR_VALID;
 }

SQLITE_PRIVATE void sqlite3BtreeCursorHints	(	BtCursor *	pCsr,
		unsigned int	mask
	)

Definition at line 62304 of file sqlite3.c.

References BtCursor::hints.

Referenced by sqlite3VdbeExec().

                                                                               {
   assert( mask==BTREE_BULKLOAD || mask==BTREE_SEEK_EQ || mask==0 );
   pCsr->hints = mask;
 }

SQLITE_PRIVATE int sqlite3BtreeCursorRestore	(	BtCursor *	pCur,
		int *	pDifferentRow
	)

Definition at line 53890 of file sqlite3.c.

References BtCursor::eState.

                                                                                 {
   int rc;
 
   assert( pCur!=0 );
   assert( pCur->eState!=CURSOR_VALID );
   rc = restoreCursorPosition(pCur);
   if( rc ){
     *pDifferentRow = 1;
     return rc;
   }
   if( pCur->eState!=CURSOR_VALID ){
     *pDifferentRow = 1;
   }else{
     assert( pCur->skipNext==0 );
     *pDifferentRow = 0;
   }
   return SQLITE_OK;
 }

SQLITE_PRIVATE int sqlite3BtreeCursorSize ( void )

Definition at line 56985 of file sqlite3.c.

                                                {
   return ROUND8(sizeof(BtCursor));
 }

SQLITE_PRIVATE void sqlite3BtreeCursorZero ( BtCursor * p )

Definition at line 56997 of file sqlite3.c.

References BtCursor::iPage.

                                                        {
   memset(p, 0, offsetof(BtCursor, iPage));
 }

SQLITE_PRIVATE int sqlite3BtreeData	(	BtCursor *	pCur,
		u32	offset,
		u32	amt,
		void *	pBuf
	)

Definition at line 57493 of file sqlite3.c.

References BtCursor::eState.

Referenced by sqlite3_blob_read(), sqlite3VdbeExec(), and sqlite3VdbeMemFromBtree().

                                                                                     {
   int rc;
 
 #ifndef SQLITE_OMIT_INCRBLOB
   if ( pCur->eState==CURSOR_INVALID ){
     return SQLITE_ABORT;
   }
 #endif
 
   assert( cursorHoldsMutex(pCur) );
   rc = restoreCursorPosition(pCur);
   if( rc==SQLITE_OK ){
     assert( pCur->eState==CURSOR_VALID );
     assert( pCur->iPage>=0 && pCur->apPage[pCur->iPage] );
     assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell );
     rc = accessPayload(pCur, offset, amt, pBuf, 0);
   }
   return rc;
 }

Data Structures

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

Typedef Documentation

Function Documentation